npm-pkg-hook 1.3.9 → 1.4.0

package/src/hooks/useSetupSchedule/index.ts

@@ -0,0 +1,284 @@
+import { useEffect, useState } from 'react'
+
+import { days as NameDays } from '../../utils'
+import { convertToMilitaryTime } from '../convertToMilitaryTime'
+import { useSchedules, useCreateSchedules } from '../useSchedule'
+import { GET_ONE_SCHEDULE_STORE, GET_SCHEDULE_STORE } from '../useSchedule/queries'
+
+import {
+  dateEnum,
+  initialDays,
+  timeSuggestions
+} from './helpers'
+export * from './helpers/index'
+
+export const useSetupSchedule = ({
+  idStore = null, sendNotification = (args) => {
+    return args
+  }
+} = {}) => {
+  const [days, setDays] = useState(initialDays === null ? [] : initialDays)
+  const [alertModal, setAlertModal] = useState(false)
+  const [selectedDay, setSelectedDay] = useState({})
+  const [setStoreSchedule] = useCreateSchedules()
+
+  const onCompleted = (data: any) => {
+    if (Array.isArray(data) && data?.length > 0) {
+      // Mapeamos los datos recibidos y los convertimos en un objeto con la estructura deseada
+      const newSchedules = data.map((day) => {return {
+        day: day.schDay,
+        name: NameDays[day.schDay],
+        selected: day.schHoEnd !== '00:00' || day.schHoSta !== '00:00',
+        ...day
+      }})
+
+      // Actualizamos el estado days
+      setDays(prevDays => {
+        // Creamos un nuevo array combinando los elementos existentes en days con los nuevos datos
+        const updatedDays = prevDays?.map(existingDay => {
+          // Buscamos si hay un elemento con el mismo día en los nuevos datos
+          const newData = newSchedules.find(newDay => {return newDay.day === existingDay.day})
+          // Si encontramos el día en los nuevos datos, lo fusionamos con el día existente
+          if (newData) {
+            return { ...existingDay, ...newData }
+          }
+          // Si no encontramos el día en los nuevos datos, simplemente devolvemos el día existente
+          return existingDay
+        })
+
+        // Ahora, buscamos los nuevos días que no están en days y los agregamos al array
+        newSchedules.forEach(newDay => {
+          if (!updatedDays.some(existingDay => {return existingDay.day === newDay.day})) {
+            updatedDays.push(newDay)
+          }
+        })
+
+        // Devolvemos el nuevo array actualizado
+        return updatedDays
+      })
+    }
+  }
+
+  const [data, { loading: lsc }] = useSchedules({ schDay: 1 })
+
+  const toggleCheck = (index) => {
+    const updatedDays = [...days]
+    updatedDays[index].checked = !updatedDays[index].checked
+    setDays(updatedDays)
+  }
+
+  const duplicateDay = (index) => {
+    const selectedDay = days[index]
+    // Lógica para desplegar el modal y seleccionar los días donde se replicará
+    const selectedDaysToDuplicate = days.filter((day) => {return day.checked})
+    const updatedDays = [...days]
+    selectedDaysToDuplicate.forEach((dayToDuplicate) => {
+      const duplicatedDay = { ...selectedDay, checked: false }
+      updatedDays.push(duplicatedDay)
+    })
+    setDays(updatedDays)
+  }
+
+  const handleSelectedDay = (day) => {
+    const isSaved = days.find((data) => {
+      return data.day === day
+    })
+    if (isSaved?.schId && isSaved?.selected) {
+      setSelectedDay(isSaved)
+      return setAlertModal(true)
+    }
+    const updatedDays = days?.map((d) => {
+      if (d.day === day) {
+        return { ...d, selected: !d.selected }
+      } 
+      return { ...d }
+      
+    })
+    setDays(updatedDays)
+  }
+  const selectedDays = days?.filter((day) => {return Boolean(day.selected)}).map((day) => {
+    return day.day
+  })
+  /**
+   *
+   * @param hora1
+   * @param hora2
+   */
+  function sumHours (hora1, hora2) {
+    const [hora1Horas, hora1Minutos] = hora1.split(':').map(Number)
+    const [hora2Horas, hora2Minutos] = hora2.split(':').map(Number)
+
+    let sumaHour = hora1Horas + hora2Horas
+    let sumMinutes = hora1Minutos + hora2Minutos
+
+    if (sumMinutes >= 60) {
+      sumMinutes -= 60
+      sumaHour++
+    }
+
+    if (sumaHour >= 24) {
+      sumaHour -= 24
+    }
+
+    const horaSumada = `${String(sumaHour).padStart(2, '0')}:${String(sumMinutes).padStart(2, '0')}`
+    return horaSumada
+  }
+  /**
+   *
+   * @param hora1
+   * @param hora2
+   */
+  function isLessThanOneHour (hora1, hora2) {
+    const suma = sumHours(hora1, hora2)
+    const [sumaHour, sumMinutes] = suma.split(':').map(Number)
+    const totalMinutos = (sumaHour * 60) + sumMinutes
+
+    if (totalMinutos < 60) {
+      return true // La suma de las horas es menor a una hora
+    }
+    return false // La suma de las horas es igual o mayor a una hora
+  }
+  const onChangeSaveHour = async ({ time, name, day }) => {
+    setDays(prevDays => {
+      const updatedDays = prevDays?.map((d) => {
+        if (d.day === day) {
+          return { ...d, [name]: time, loading: Boolean(name === dateEnum.schHoEnd) }
+        } 
+        return { ...d }
+        
+      })
+
+      if (name === dateEnum.schHoEnd) {
+        const findHour = updatedDays.find((d) => {
+          return d.day === day
+        })
+        const schHoSta = findHour?.schHoSta
+        const schHoEnd = findHour?.schHoEnd
+        const startHour = convertToMilitaryTime(schHoSta)
+        const endHour = convertToMilitaryTime(schHoEnd)
+        if (isLessThanOneHour(startHour, endHour)) {
+           
+          sendNotification({
+            description: 'Error, el horario debe ser mayor a una hora',
+            title: 'Error',
+            backgroundColor: 'error'
+          })
+        }
+        // Comparar solo las horas y minutos
+        if (startHour === endHour) {
+           
+          sendNotification({
+            description: 'Error, la hora de salida no debe ser igual a la hora final',
+            title: 'Error',
+            backgroundColor: 'error'
+          })
+        }
+        if (startHour > endHour) {
+           
+          sendNotification({
+            description: 'Error, la hora de salida debe ser mayor que la de entrada',
+            title: 'Error',
+            backgroundColor: 'error'
+          })
+        }
+
+        if (startHour !== endHour && startHour < endHour && !isLessThanOneHour(startHour, endHour)) {
+          setStoreSchedule({
+            variables: {
+              input: {
+                schHoSta: schHoSta ?? '00:00',
+                schHoEnd: schHoEnd ?? '00:00',
+                schState: 1,
+                schDay: day
+              }
+            },
+            update (cache) {
+              cache.modify({
+                fields: {
+                  getStoreSchedules (dataOld = []) {
+                    return cache.writeQuery({ query: GET_SCHEDULE_STORE, data: dataOld })
+                  },
+                  getOneStoreSchedules (dataOld = []) {
+                    return cache.writeQuery({ query: GET_ONE_SCHEDULE_STORE, data: dataOld })
+                  }
+                }
+              })
+            }
+          })
+        }
+        const newUpdatedDays = updatedDays.map((d) => {
+          if (d.day === day) {
+            return { ...d, loading: false }
+          } 
+          return { ...d }
+          
+        })
+        // Devolver el nuevo estado actualizado
+        return newUpdatedDays
+      }
+      // Devolver el nuevo estado
+      return updatedDays
+    })
+  }
+
+  const handleDeleteSchedule = async (day) => {
+    await setStoreSchedule({
+      variables: {
+        input: {
+          schHoSta: '00:00',
+          schHoEnd: '00:00',
+          schState: 1,
+          schDay: day,
+          idStore
+        }
+      },
+      update (cache) {
+        cache.modify({
+          fields: {
+            getStoreSchedules (dataOld = []) {
+              return cache.writeQuery({ query: GET_SCHEDULE_STORE, data: dataOld })
+            },
+            getOneStoreSchedules (dataOld = []) {
+              return cache.writeQuery({ query: GET_ONE_SCHEDULE_STORE, data: dataOld })
+            }
+          }
+        })
+      }
+    })
+    setDays(prevDays => {
+      if (!prevDays) return []
+      const updatedDays = prevDays?.map((d) => {
+        if (d.day === day) {
+          return {
+            ...d,
+            [dateEnum.schHoEnd]: dateEnum?.schHoEnd,
+            [dateEnum.schHoSta]: dateEnum?.schHoSta,
+            selected: false
+          }
+        } 
+        return { ...d }
+        
+      })
+      return updatedDays
+    })
+    setAlertModal(false)
+  }
+  useEffect(() => {
+    onCompleted(data)
+  }, [data])
+
+  return {
+    duplicateDay,
+    toggleCheck,
+    handleSelectedDay,
+    onChangeSaveHour,
+    handleDeleteSchedule,
+    setAlertModal,
+    days,
+    selectedDays,
+    selectedDay,
+    alertModal,
+    loading: lsc,
+    times: timeSuggestions
+  }
+}

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

@@ -0,0 +1,124 @@
+export const getDayFromOpeningKey = (key) => {
+  const days = {
+    openingSun: 0,
+    openingMon: 1,
+    openingTue: 2,
+    openingWed: 3,
+    openingThu: 4,
+    openingFri: 5,
+    openingSat: 6
+  }
+  return days[key] !== undefined ? days[key] : -1
+}
+
+// Función para convertir el objeto de tiempo en una cadena de tiempo
+/**
+ *
+ * @param timeStr
+ */
+export function getTimeString (timeStr) {
+  return timeStr || '00:00' // Return '00:00' for empty time strings
+}
+
+/**
+ *
+ */
+export function getCurrentDayAndTime () {
+  try {
+    const date = new Date()
+    const currentTime = date.getHours() * 60 + date.getMinutes()
+    const currentDayOfWeek = date.getDay()
+    return { currentTime, currentDayOfWeek }
+  } catch (error) {
+    return {
+
+    }
+  }
+}
+
+/**
+ *
+ * @param timeStr
+ */
+export function getTimeObject (timeStr) {
+  try {
+    if (!timeStr || !/\d{2}:\d{2}/.test(timeStr)) {
+      return { hours: 0, minutes: 0 } // Return default values for invalid input
+    }
+    const [hours, minutes] = timeStr.split(':').map(str => {return parseInt(str)})
+    return { hours, minutes }
+  } catch (e) {
+    return { hours: 0, minutes: 0 } // Return default values on error
+  }
+}
+
+/**
+ *
+ * @param openings
+ */
+export function sortOpeningsByDay (openings) {
+  const days = [
+    'openingSun',
+    'openingMon',
+    'openingTue',
+    'openingWed',
+    'openingThu',
+    'openingFri',
+    'openingSat'
+  ]
+  const sortedOpenings = {}
+
+  days.forEach((day) => {
+    sortedOpenings[day] = openings[day] || '00:00 - 00:00' // Agregar horario vacío para los días faltantes
+  })
+
+  return sortedOpenings
+}
+
+// Función para obtener la clave de openings a partir del día de la semana
+/**
+ *
+ * @param day
+ */
+export function getOpeningKeyFromDay (day) {
+  const days = {
+    0: 'openingSun',
+    1: 'openingMon',
+    2: 'openingTue',
+    3: 'openingWed',
+    4: 'openingThu',
+    5: 'openingFri',
+    6: 'openingSat'
+  }
+  return days[day]
+}
+
+export const weekDays = [
+  'Domingo',
+  'Lunes',
+  'Martes',
+  'Miércoles',
+  'Jueves',
+  'Viernes',
+  'Sábado'
+]
+
+/**
+ *
+ * @param text
+ */
+export function timeToInt (text) {
+  const hour = parseInt(text.substring(0, 2))
+  const minute = parseInt(text.substring(3))
+  return hour * 60 + minute
+}
+
+export const days = {
+  Monday: 'Lunes',
+  Tuesday: 'Martes',
+  Wednesday: 'Miércoles',
+  Thursday: 'Jueves',
+  Friday: 'Viernes',
+  Saturday: 'Sábado',
+  Sunday: 'Domingo'
+}

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

@@ -1,4 +1,7 @@
-import { useEffect, useState } from 'react'
+import { useEffect, useState } from 'react'
+
+import { useFormatDate } from '../useFormatDate'
+
 import {
   getDayFromOpeningKey,
   getCurrentDayAndTime,
@@ -10,18 +13,24 @@ import {
   days,
   getTimeObject
 } from './helpers'
-import { useFormatDate } from '../useFormatDate'
 
 export const useStatusOpenStore = ({ dataSchedules = [] } = {}) => {
   const [open, setOpen] = useState('')
   const [openNow, setOpenNow] = useState(false)
-  const { handleHourPmAM } = useFormatDate({})
+  const { handleHourPmAM } = useFormatDate({
+    date: null
+  })
 
   const handleMessageHour = (message, open) => {
     setOpen(message)
     setOpenNow(open)
   }
 
+  /**
+   *
+   * @param dataSchedules
+   * @param currentDayOfWeek
+   */
   function getNextDaySchedule (dataSchedules, currentDayOfWeek) {
     const today = new Date()
     const tomorrow = new Date(today)
@@ -29,16 +38,22 @@ export const useStatusOpenStore = ({ dataSchedules = [] } = {}) => {
     const dayOfWeekTomorrow = tomorrow.getDay()
 
     const findNextDay = dataSchedules?.length
-      ? dataSchedules?.some((schedule) => schedule?.schDay === dayOfWeekTomorrow)
+      ? dataSchedules?.some((schedule) => {return schedule?.schDay === dayOfWeekTomorrow})
       : false
 
     const findDataNextDay = dataSchedules?.length
-      ? dataSchedules?.find((schedule) => schedule?.schDay === dayOfWeekTomorrow)
+      ? dataSchedules?.find((schedule) => {return schedule?.schDay === dayOfWeekTomorrow})
       : {}
 
     return { findNextDay, findDataNextDay, dayOfWeekTomorrow }
   }
 
+  /**
+   *
+   * @param openings
+   * @param currentTime
+   * @param currentDayOfWeek
+   */
   function getOpeningStatus (openings, currentTime, currentDayOfWeek) {
     const weekDayLookup = [
       'Sunday',
@@ -56,10 +71,10 @@ export const useStatusOpenStore = ({ dataSchedules = [] } = {}) => {
     for (let i = 0; i < 7; i++) {
       const dayName = weekDayLookup[dayOfWeek % 7]
       const opening = openings && openings['opening' + dayName.substring(0, 3)]
-      const timeSpans = opening?.split(';').map((item) => item.trim())
+      const timeSpans = opening?.split(';').map((item) => {return item.trim()})
 
       for (const span of timeSpans) {
-        const hours = span.split('-').map((item) => item.trim())
+        const hours = span.split('-').map((item) => {return item.trim()})
         const openTime = timeToInt(hours[0])
         const closeTime = timeToInt(hours[1])
 
@@ -84,7 +99,11 @@ export const useStatusOpenStore = ({ dataSchedules = [] } = {}) => {
           )
         }
 
-        const { findNextDay, findDataNextDay, dayOfWeekTomorrow } = getNextDaySchedule(
+        const {
+          findNextDay,
+          findDataNextDay,
+          dayOfWeekTomorrow
+        } = getNextDaySchedule(
           dataSchedules,
           currentDayOfWeek
         )
@@ -92,16 +111,16 @@ export const useStatusOpenStore = ({ dataSchedules = [] } = {}) => {
         if (findNextDay && findDataNextDay?.schHoSta) {
           const nameOfDayTomorrow = weekDays[dayOfWeekTomorrow]
           return handleMessageHour(
-                `Cerrado - Mañana ${nameOfDayTomorrow} ${!!findDataNextDay?.schHoSta && 'a las'} ${
-                  findDataNextDay?.schHoSta ? findDataNextDay?.schHoSta : ''
-                }`,
-                false
+            `Cerrado abre Mañana ${nameOfDayTomorrow} ${Boolean(findDataNextDay?.schHoSta) && 'a las'} ${
+              handleHourPmAM(findDataNextDay?.schHoSta) ?? ''
+            }`,
+            false
           )
         }
 
         const nextDayName = weekDayLookup[(dayOfWeek + 1) % 7]
-        const nextOpening = openings && openings['opening' + nextDayName.substring(0, 3)]
-        const nextHours = nextOpening?.split(';')?.map((item) => item?.trim())
+        const nextOpening = openings?.['opening' + nextDayName.substring(0, 3)]
+        const nextHours = nextOpening?.split(';')?.map((item) => {return item?.trim()})
 
         if (nextHours[0] !== ceroHours) {
           return handleMessageHour(
@@ -117,6 +136,10 @@ export const useStatusOpenStore = ({ dataSchedules = [] } = {}) => {
     return handleMessageHour('Cerrado', false)
   }
 
+  /**
+   *
+   * @param openings
+   */
   function getIsOpening (openings) {
     const { currentTime, currentDayOfWeek } = getCurrentDayAndTime()
     return getOpeningStatus(openings, currentTime, currentDayOfWeek)
@@ -147,10 +170,10 @@ export const useStatusOpenStore = ({ dataSchedules = [] } = {}) => {
       const sortedOpenings = sortOpeningsByDay(openings)
 
       // Crear el array completo con objetos de tiempo
-      // eslint-disable-next-line no-unused-vars
+       
       const fullArray = Object.keys(sortedOpenings).map((key) => {
         const day = getDayFromOpeningKey(key)
-        const [schHoSta, schHoEnd] = openings[key].split(' - ').map(timeStr => getTimeObject(timeStr))
+        const [schHoSta, schHoEnd] = openings[key].split(' - ').map(timeStr => {return getTimeObject(timeStr)})
         return {
           __typename: 'StoreSchedule',
           schId: '',

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

@@ -1,6 +1,7 @@
-import { useQuery } from '@apollo/client'
-import { GET_ALL_PEDIDOS_STATUS } from './queries'
+import { useQuery } from '@apollo/client'
+
 import { filterOrders } from './helpers'
+import { GET_ALL_PEDIDOS_STATUS } from './queries'
 
 export const useStatusOrdersClient = () => {
   const { data, loading, error } = useQuery(GET_ALL_PEDIDOS_STATUS, {

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

@@ -6,7 +6,7 @@ export const GET_ALL_PEDIDOS_STATUS = gql`
       pdpId
       idStore
       pCodeRef
-      payMethodPState
+      payId
       pPRecoger
       totalProductsPrice
       pSState
@@ -48,7 +48,7 @@ export const GET_ALL_PEDIDOS_STATUS = gql`
         ShoppingCard
         pCodeRef
         pPStateP
-        payMethodPState
+        payId
         pPRecoger
         pDatCre
         pDatMod

package/src/hooks/useStock/index.ts

@@ -0,0 +1 @@
+export { useStockUpdatedAllSubscription } from './useStockUpdatedAllSubscription'

package/src/hooks/useStock/useStockUpdatedAllSubscription.ts

@@ -0,0 +1,40 @@
+
+import { useSubscription, gql } from '@apollo/client'
+
+const NEW_STORE_ORDER_SUBSCRIPTION = gql`
+ subscription StockUpdatedAll($idStore: String) {
+    StockUpdatedAll(idStore: $idStore) {
+      pId
+      newStock
+      previousStock
+      event
+      meta
+    }
+  } 
+`
+
+interface StockUpdatedAllData {
+    StockUpdatedAll: {
+        pId: string
+        newStock: number
+        previousStock: number
+        event: string
+        meta: any
+    }
+}
+
+export const useStockUpdatedAllSubscription = (
+  idStore: string,
+  onStockUpdated: (data: StockUpdatedAllData['StockUpdatedAll']) => void
+) => {
+  return useSubscription<StockUpdatedAllData>(NEW_STORE_ORDER_SUBSCRIPTION, {
+    variables: { idStore },
+    skip: !idStore,
+    onSubscriptionData: ({ subscriptionData }) => {
+      const data = subscriptionData.data?.StockUpdatedAll
+      if (!data) return
+      onStockUpdated(data)
+    }
+  })
+}
+

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

@@ -0,0 +1,16 @@
+export const fillMissingDates = (data, days = 7) => {
+  const today = new Date()
+  const filledData = []
+
+  for (let i = days - 1; i >= 0; i--) {
+    const date = new Date()
+    date.setDate(today.getDate() - i)
+
+    const formattedDate = date.toISOString().split('T')[0] // "YYYY-MM-DD"
+    const existingData = data.find(item => {return item.date === formattedDate})
+
+    filledData.push(existingData || { date: formattedDate, TotalIn: 0, TotalOut: 0, TotalAdjustment: 0 })
+  }
+
+  return filledData
+}

package/src/hooks/useStockMovements/index.ts

@@ -0,0 +1,39 @@
+import { useQuery, gql } from '@apollo/client'
+import { useState, useEffect } from 'react'
+
+import { fillMissingDates } from './helpers'
+
+const GET_STOCK_MOVEMENTS = gql`
+  query {
+    getStockMovementsByDay {
+      date
+      total_in,
+      total_adjustment
+      total_out
+    }
+  }
+`
+
+/**
+ * Custom hook to fetch stock movements data for visualization.
+ * @returns {Object} { data, loading, error }
+ */
+export const useStockMovements = () => {
+  const { data, loading, error } = useQuery(GET_STOCK_MOVEMENTS)
+  const [chartData, setChartData] = useState([])
+
+  useEffect(() => {
+    if (data && data.getStockMovementsByDay) {
+      // Transform data to be compatible with Recharts
+      const formattedData = data.getStockMovementsByDay.map(entry => {return {
+        date: entry.date,
+        TotalIn: entry.total_in ?? 0,
+        TotalOut: entry.total_out ?? 0,
+        TotalAdjustment: entry.total_adjustment ?? 0
+      }})
+      setChartData(formattedData)
+    }
+  }, [data])
+
+  return [fillMissingDates(chartData), { loading, error }]
+}