npm-pkg-hook 1.13.1 → 1.13.2

package/src/hooks/useSales/types/use-sales.types.ts

@@ -0,0 +1,8 @@
+import { NotificationPayload } from '.'
+
+export interface UseSalesProps {
+  disabled?: boolean;
+  router?: any;
+  sendNotification?: (args: NotificationPayload) => any;
+  setAlertBox?: (args: any) => any;
+}

package/src/hooks/useSales/useGetSale.ts

@@ -0,0 +1,21 @@
+import { useLazyQuery } from '@apollo/client'
+
+import { GET_ONE_SALE } from './queries'
+
+export const useGetSale = () => {
+  const [getOneSalesStore, { loading, data, called, error }] = useLazyQuery(GET_ONE_SALE)
+
+  const handleGetSale = async (pCodeRef) => {
+    return await getOneSalesStore({
+      variables: { pCodeRef }
+    })
+  }
+  return {
+    data: data?.getOneSalesStore,
+    loading,
+    error,
+    called,
+    getOneSalesStore,
+    handleGetSale
+  }
+}

package/src/hooks/useSales/useTotalSales.ts

@@ -0,0 +1,24 @@
+import { useApolloClient, useQuery } from '@apollo/client'
+
+import { GET_ALL_COUNT_SALES } from './queries'
+
+export const useTotalSales = () => {
+  const client = useApolloClient()
+
+  const { data, loading, error } = useQuery(GET_ALL_COUNT_SALES, {
+    fetchPolicy: 'cache-and-network',
+    notifyOnNetworkStatusChange: true,
+    nextFetchPolicy: 'cache-first',
+    refetchWritePolicy: 'merge'
+  })
+
+  // Guarda la respuesta en la caché manualmente (opcional)
+  if (data) {
+    client.writeQuery({ query: GET_ALL_COUNT_SALES, data })
+  }
+
+  return [data?.getTodaySales || 0, {
+    loading,
+    error
+  }]
+}

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

@@ -0,0 +1,38 @@
+export const days = [
+  {
+    day: 1,
+    name: 'L'
+  },
+  {
+    day: 2,
+    name: 'M'
+  },
+  {
+    day: 3,
+    name: 'MI'
+  },
+  {
+    day: 4,
+    name: 'J'
+  },
+  {
+    day: 5,
+    name: 'V'
+  },
+  {
+    day: 6,
+    name: 'S'
+  },
+  {
+    day: 0,
+    name: 'D'
+  }
+]
+
+export const arraysAreEqual = (arr1, arr2) => {
+  if (arr1.length !== arr2.length) return false
+  for (let i = 0; i < arr1.length; i++) {
+    if (arr1[i] !== arr2[i]) return false
+  }
+  return true
+}

package/src/hooks/useSaveAvailableProduct/index.ts

@@ -0,0 +1,32 @@
+import { useMutation } from '@apollo/client'
+import { useState } from 'react'
+
+import { days } from './helpers/index'
+import { CREATE_AVAILABLE_PRODUCTS_DAYS } from './queries'
+
+export const useSaveAvailableProduct = () => {
+  const [selectedDays, setSelectedDays] = useState([])
+
+  const handleDaySelection = (day) => {
+    if (selectedDays.includes(day)) {
+      setSelectedDays(selectedDays.filter((selectedDay) => { return selectedDay !== day }))
+    } else {
+      setSelectedDays([...selectedDays, day])
+    }
+  }
+  const handleCleanSelectedDays = () => {
+    setSelectedDays([])
+  }
+  const [registerAvailableProduct, { loading }] = useMutation(CREATE_AVAILABLE_PRODUCTS_DAYS, {
+    onError: () => { return console.log({ message: 'Lo sentimos ocurrió un error, vuelve a intentarlo' }) }
+  })
+  return {
+    handleDaySelection,
+    handleCleanSelectedDays,
+    selectedDays,
+    setSelectedDays,
+    days,
+    Loading: loading,
+    registerAvailableProduct
+  }
+}

package/src/hooks/useSaveAvailableProduct/queries.ts

@@ -0,0 +1,10 @@
+import { gql } from '@apollo/client'
+
+export const CREATE_AVAILABLE_PRODUCTS_DAYS = gql`
+mutation registerAvailableProduct($input: [IAvailableProduct]) {
+    registerAvailableProduct(input: $input) {
+    success
+    message
+  }
+}
+`

package/src/hooks/useSaveLocation/index.ts

@@ -0,0 +1,17 @@
+import { useMutation } from '@apollo/client'
+
+import { SAVE_LOCATION_USER } from './queries'
+
+export const useSaveLocation = () => {
+  const [updateUserLocations, { loading, error, data }] =
+    useMutation(SAVE_LOCATION_USER)
+
+  return [
+    updateUserLocations,
+    {
+      loading,
+      error,
+      data
+    }
+  ]
+}

package/src/hooks/useSaveLocation/queries.ts

@@ -0,0 +1,19 @@
+import { gql } from '@apollo/client'
+
+export const SAVE_LOCATION_USER = gql`
+mutation updateUserLocations($input: InputUserLocation) {
+  updateUserLocations(input: $input) {
+    locationId
+    id
+    cId
+    dId
+    ctId
+    uLatitud
+    uLongitude
+    uLocationKnow
+    uPiso
+    DatCre
+    DatMod
+  }
+}
+`

package/src/hooks/useSchedule/index.ts

@@ -0,0 +1,35 @@
+import { useMutation, useQuery } from '@apollo/client'
+
+import { GET_ONE_SCHEDULE_STORE, GET_SCHEDULE_STORE } from '../useProductsFood/queriesStore'
+import { CREATE_STORE_CALENDAR } from '../useSchedule/queries'
+export * from './schedule'
+
+export const useSchedule = ({ day = null, idStore = '' }) => {
+  const {
+    data,
+    loading,
+    error
+  } = useQuery(GET_ONE_SCHEDULE_STORE, { variables: { schDay: day, idStore } })
+
+  return [data?.getOneStoreSchedules, { loading, error }]
+}
+
+export const useSchedules = ({ schDay = 1, idStore = '' }) => {
+  const {
+    data,
+    loading,
+    error
+  } = useQuery(GET_SCHEDULE_STORE, { variables: { schDay, idStore } })
+
+  return [data?.getStoreSchedules, { loading, error }]
+}
+
+export const useCreateSchedules = () => {
+  const [setStoreSchedule, { loading, error }] = useMutation(CREATE_STORE_CALENDAR, {
+    onError: (e) => {
+      console.error(e)
+    }
+  })
+
+  return [setStoreSchedule, { loading, error }]
+}

package/src/hooks/useSchedule/queries.ts

@@ -0,0 +1,43 @@
+import { gql } from '@apollo/client'
+
+export const CREATE_STORE_CALENDAR = gql`
+mutation  setStoreSchedule($input: ITstoreSchedule!){
+  setStoreSchedule(input: $input){
+    message
+    success
+  }
+}
+`
+export const GET_SCHEDULE_STORE = gql`
+  query getStoreSchedules($schDay: Int, $idStore: ID) {
+    getStoreSchedules(schDay: $schDay, idStore: $idStore) {
+      schId
+      idStore
+      schDay
+      schHoSta
+      schHoEnd
+      schState
+    }
+  }
+`
+
+export const GET_ONE_SCHEDULE_STORE = gql`
+  query getOneStoreSchedules($schDay: Int, $idStore: ID) {
+    getOneStoreSchedules(schDay: $schDay, idStore: $idStore) {
+      schId
+      schDay
+      schHoSta
+      schHoEnd
+      schState
+    }
+  }
+`
+
+export const SET_STATUS_ALL_SCHEDULE_STORE = gql`
+mutation setScheduleOpenAll($scheduleOpenAll: Boolean!) {
+  setScheduleOpenAll(scheduleOpenAll: $scheduleOpenAll) {
+    success
+    message
+  }
+}
+`

package/src/hooks/useSchedule/schedule.ts

@@ -0,0 +1,79 @@
+import { useQuery, useMutation } from '@apollo/client'
+
+import {
+  GET_ONE_SCHEDULE_STORE,
+  GET_SCHEDULE_STORE,
+  CREATE_STORE_CALENDAR,
+  SET_STATUS_ALL_SCHEDULE_STORE
+} from './queries'
+
+export const useSchedule = ({ day = null, idStore = '' }) => {
+  const {
+    data,
+    loading,
+    error
+  } = useQuery(GET_ONE_SCHEDULE_STORE, { variables: { schDay: day, idStore } })
+
+  return [data?.getOneStoreSchedules, { loading, error }]
+}
+
+export const useSetScheduleOpenAll = () => {
+  const [setStoreSchedule, { loading, error }] = useMutation(SET_STATUS_ALL_SCHEDULE_STORE, {
+    onError: (e) => {
+      console.error(e)
+    }
+  })
+
+  const handleSetStoreSchedule = (scheduleOpenAll) => {
+    setStoreSchedule({
+      variables: {
+        scheduleOpenAll
+      },
+      update: (cache, { data }) => {
+        const success = data?.setScheduleOpenAll?.success
+        if (success) {
+          cache.modify({
+            fields: {
+              getStore (_, { readField }) {
+                const store = readField('getStore')
+                const updatedCart = {
+                  ...store,
+                  scheduleOpenAll
+                }
+                return updatedCart
+              }
+            }
+          })
+        }
+      }
+    })
+  }
+
+  return [handleSetStoreSchedule, { loading, error }]
+}
+
+export const useSchedules = ({ schDay = 1, idStore = '', onCompleted = (data) => { return data } }) => {
+  const {
+    data,
+    loading,
+    error
+  } = useQuery(GET_SCHEDULE_STORE, {
+    variables: { schDay, idStore },
+    onCompleted: (data) => {
+      onCompleted(data)
+    }
+  }
+  )
+
+  return [data?.getStoreSchedules, { loading, error }]
+}
+
+export const useCreateSchedules = () => {
+  const [setStoreSchedule, { loading, error }] = useMutation(CREATE_STORE_CALENDAR, {
+    onError: (e) => {
+      console.error(e)
+    }
+  })
+
+  return [setStoreSchedule, { loading, error }]
+}

package/src/hooks/useScheduleData/index.ts

@@ -0,0 +1,135 @@
+/**
+ *
+ * @param data
+ */
+export function useScheduleData (data) {
+  const days = {
+    1: 'Lunes',
+    2: 'Martes',
+    3: 'Miércoles',
+    4: 'Jueves',
+    5: 'Viernes',
+    6: 'Sabado',
+    0: 'Domingo'
+  }
+
+  const daysArray = [
+    { day: 0, schHoSta: '', schHoEnd: '' },
+    { day: 1, schHoSta: '', schHoEnd: '' },
+    { day: 2, schHoSta: '', schHoEnd: '' },
+    { day: 3, schHoSta: '', schHoEnd: '' },
+    { day: 4, schHoSta: '', schHoEnd: '' },
+    { day: 5, schHoSta: '', schHoEnd: '' },
+    { day: 6, schHoSta: '', schHoEnd: '' }
+  ]
+
+  const combinedArray = daysArray.map((dayObj) => {
+    const originalObj = data?.find((item) => {return item.schDay === dayObj.day})
+    return originalObj || { ...dayObj }
+  })
+
+  // Encontrar la hora de inicio más temprana en combinedArray
+  const earliestStartTime = Math.min(
+    ...combinedArray.map((item) => {
+      const time = new Date(`2023-08-01 ${item.schHoSta}`)
+      return time.getTime()
+    })
+  )
+
+  const calculateYPosition = (start) => {
+    const time = new Date(`2023-08-01 ${start}`)
+    const differenceInMinutes = (time.getTime() - earliestStartTime) / (1000 * 40)
+    return differenceInMinutes / 40 // Ajusta el valor para adaptarse a la posición deseada en el eje Y
+  }
+
+  /**
+   * Calcula la duración en horas entre dos horas de inicio y final.
+   * @param {string} startTime - Hora de inicio en formato 'HH:mm'.
+   * @param {string} endTime - Hora de fin en formato 'HH:mm'.
+   * @returns {number|string} Duración en horas con dos decimales.
+   */
+
+  // Función para calcular la duración en horas de un horario
+  /**
+   *
+   * @param startTime
+   * @param endTime
+   */
+  function calculateDurationInHours (startTime, endTime) {
+    const startHour = new Date(`2000-01-01T${startTime}`)
+    const endHour = new Date(`2000-01-01T${endTime}`)
+    const duration = (endHour - startHour) / (1000 * 40 * 40) // Convertir la diferencia en horas
+    return duration.toFixed(2) // Redondear a 2 decimales
+  }
+
+  // Variables para controlar la posición en el eje X
+  const columnIndex = 0
+  const lastDay = -1
+  const uniqueHoursSet = new Set([
+    ...combinedArray.map((item) => {return item.schHoSta}),
+    ...combinedArray.map((item) => {return item.schHoEnd})
+  ])
+
+  const uniqueHours = []
+  for (const hour of uniqueHoursSet) {
+    const time = new Date(`2023-08-01 ${hour}`)
+    const formattedHour = time.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', hour12: false })
+    uniqueHours.push(formattedHour)
+  }
+
+  uniqueHours.sort((a, b) => {
+    const timeA = new Date(`2023-08-01 ${a}`)
+    const timeB = new Date(`2023-08-01 ${b}`)
+    return timeA - timeB
+  })
+
+  // Agregar las horas que faltan al final del día
+  if (uniqueHours.length > 0) {
+    const lastHour = new Date(`2023-08-01 ${uniqueHours[uniqueHours.length - 1]}`)
+    const endTime = new Date(`2023-08-01 ${combinedArray[0].schHoEnd}`)
+    const hoursDifference = (endTime - lastHour) / (1000 * 60 * 60)
+
+    for (let i = 1; i <= hoursDifference; i++) {
+      const newHour = new Date(lastHour.getTime() + i * 60 * 60 * 1000)
+      const formattedNewHour = newHour.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', hour12: false })
+      uniqueHours.push(formattedNewHour)
+    }
+  }
+
+  const dayWidth = 120
+  const daysWithHours = Array.from(new Set(combinedArray.map((item) => {return (item.schDay !== undefined ? item.schDay : item.day)})))
+  const totalDays = daysWithHours.length
+  const totalWidth = totalDays * dayWidth
+
+  const sortedUniqueHours = Array.from(uniqueHoursSet)
+    .sort((a, b) => {
+      const timeA = new Date(`2023-08-01 ${a}`)
+      const timeB = new Date(`2023-08-01 ${b}`)
+      return timeA - timeB
+    })
+
+  const formattedHours = sortedUniqueHours
+
+  /**
+   *
+   */
+  function calculateTimeLinesHeight () {
+    const totalHours = uniqueHours.length
+    return totalHours * 60 // Cada hora ocupa 60 píxeles de altura
+  }
+  return {
+    columnIndex,
+    combinedArray,
+    days,
+    daysArray,
+    daysWithHours,
+    dayWidth,
+    lastDay,
+    totalWidth,
+    sortedUniqueHours,
+    uniqueHours: formattedHours,
+    calculateDurationInHours,
+    calculateTimeLinesHeight,
+    calculateYPosition
+  }
+}

package/src/hooks/useScroll/index.ts

@@ -0,0 +1,56 @@
+import { useEffect, useState } from 'react'
+
+export const useScrollY = () => {
+  // Función scroll Para mover verticalmente
+  const [offsetY, setOffsetY] = useState(0)
+  const handleScroll = () => { return setOffsetY(window.pageYOffset) }
+
+  useEffect(() => {
+    window.addEventListener('scroll', handleScroll)
+    return () => { return window.removeEventListener('scroll', handleScroll) }
+  }, [])
+  return {
+    offsetY
+  }
+}
+
+export const useScrollColor = () => {
+  const [scrollNav, setScrollNav] = useState(false)
+  const changeNav = () => {
+    if (window?.scrollY >= 1) {
+      setScrollNav(true)
+    } else {
+      setScrollNav(false)
+    }
+  }
+  useEffect(() => {
+    window.addEventListener('scroll', changeNav)
+  }, [])
+  return {
+    scrollNav
+  }
+}
+
+export const useScrollHook = () => {
+  const [style, setStyle] = useState({})
+
+  useEffect(() => {
+    let scrollPos = 0
+    const handleChangeHeaderStyle = () => {
+      if (document.body?.getBoundingClientRect && document.body.getBoundingClientRect().top > scrollPos) {
+        setStyle({})
+      } else {
+        setStyle({ transform: 'translateY(-300%)' })
+      }
+      scrollPos = document.body.getBoundingClientRect().top
+    }
+
+    window.addEventListener('scroll', handleChangeHeaderStyle)
+
+    return () => {
+      window.removeEventListener('scroll', handleChangeHeaderStyle)
+    }
+  }, [])
+
+  return style
+}

package/src/hooks/useScrollRotate/index.ts

@@ -0,0 +1,16 @@
+import { useEffect, useState } from 'react'
+
+// Función scroll Para rotar
+export const useScrollRotate = () => {
+  const [position, setPosition] = useState(0)
+
+  useEffect(() => {
+    const handleScroll = () => { return setPosition(window.scrollY) }
+    window.addEventListener('scroll', handleScroll)
+    return () => {
+      window.removeEventListener('scroll', handleScroll)
+    }
+  }, [])
+
+  return { position }
+}

package/src/hooks/useSetImageProducts/index.ts

@@ -0,0 +1,59 @@
+import { useMutation, useApolloClient } from '@apollo/client'
+
+import { GET_ONE_PRODUCTS_FOOD } from '../useProductsFood/queriesStore'
+
+import { UPDATE_IMAGE_PRODUCT_FOOD } from './queries'
+
+/**
+ * Hook to update product image and sync Apollo cache.
+ *
+ * @returns {[Function, Object]} mutation function and its state
+ */
+export const useSetImageProducts = () => {
+  const client = useApolloClient()
+
+  const [setImageProducts, { data, loading, error }] = useMutation(UPDATE_IMAGE_PRODUCT_FOOD)
+
+  /**
+   * Updates product image and manually updates Apollo cache.
+   *
+   * @param {Object} variables - Requires pId and image
+   * @returns {Promise<any>}
+   */
+  const updateImageProducts = async (variables) => {
+    const { pId, image } = variables
+
+    if (!pId || !image) throw new Error('Missing pId or image')
+
+    const response = await setImageProducts({
+      variables: { input: { pId, image } }
+    })
+    const { ProImage } = response?.data?.setImageProducts?.data ?? {}
+    try {
+      const existing = client.readQuery({
+        query: GET_ONE_PRODUCTS_FOOD,
+        variables: { pId }
+      })
+
+      if (!existing?.productFoodsOne) return response
+
+      // 📝 Escribir de nuevo el producto con la imagen actualizada
+      client.writeQuery({
+        query: GET_ONE_PRODUCTS_FOOD,
+        variables: { pId },
+        data: {
+          productFoodsOne: {
+            ...existing.productFoodsOne,
+            ProImage
+          }
+        }
+      })
+    } catch (err) {
+      console.warn('⚠️ Error updating cache for GET_ONE_PRODUCTS_FOOD:', err)
+    }
+
+    return response
+  }
+
+  return [updateImageProducts, { data, loading, error }]
+}

package/src/hooks/useSetImageProducts/queries.ts

@@ -0,0 +1,18 @@
+import { gql } from '@apollo/client'
+
+export const UPDATE_IMAGE_PRODUCT_FOOD = gql`
+  mutation setImageProducts($input: IFileImageProductFood) {
+    setImageProducts(input: $input) {
+      success
+      message
+      data {
+        pId
+        ProImage
+        __typename
+      }
+      errors {
+        message
+      }
+    }
+  }
+`

package/src/hooks/useSetSession/index.ts

@@ -0,0 +1,44 @@
+import { Cookies } from '../../cookies'
+import { getCurrentDomain } from '../../utils'
+
+export const useSetSession = () => {
+  const handleSession = async (props) => {
+    try {
+      const { cookies } = props
+      let domain = getCurrentDomain()
+
+      // Si estás en entorno local, usa 'localhost' como dominio
+      if (domain === 'localhost') {
+        domain = undefined // Esto permitirá la cookie en 'localhost'
+      }
+
+      if (!Array.isArray(cookies)) {
+        throw new Error('Input cookies should be an array.')
+      }
+
+      for (const { name, value, domain: incomingDomain } of cookies) {
+        if (value) {
+          const expirationTime = new Date()
+          expirationTime.setTime(expirationTime.getTime() + 8 * 60 * 60 * 1000)
+
+          const formattedDomain = incomingDomain || domain
+
+          await Cookies.set(name, value, {
+            domain: formattedDomain,
+            path: '/',
+            secure: process.env.NODE_ENV === 'production',
+            sameSite: process.env.NODE_ENV === 'production' ? 'none' : 'lax',
+            expires: expirationTime
+          })
+        }
+      }
+
+      console.log('Cookies guardadas correctamente.')
+    } catch (error) {
+      console.error('Error al guardar las cookies:', error)
+      throw new Error('Error al guardar las cookies.')
+    }
+  }
+
+  return [handleSession]
+}

package/src/hooks/useSetState/index.ts

@@ -0,0 +1,24 @@
+import { useEffect, useState } from 'react'
+
+export const useSetState = initialState => {
+  const [state, setState] = useState(initialState)
+  const increase = () => { return setState(state + 1) }
+  const decrease = () => { return setState(state - 1) }
+  const reset = () => { return setState(0) }
+  useEffect(() => {
+    if (state === -1) return reset()
+    return {}
+  }, [state])
+  // Cambio de estado
+  const changeState = () => {
+    setState(!state)
+  }
+  return {
+    state,
+    increase,
+    decrease,
+    reset,
+    changeState,
+    setState
+  }
+}