npm-pkg-hook 1.12.7 → 1.12.8

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

@@ -0,0 +1,85 @@
+export const dateEnum = {
+  schHoEnd: 'schHoEnd',
+  schHoSta: 'schHoSta'
+
+}
+export const initialDays = [
+  {
+    name: 'Lunes',
+    day: 1,
+    checked: false,
+    schHoSta: '00:00',
+    schHoEnd: '00:00',
+    selected: false,
+    loading: false
+  },
+  {
+    name: 'Martes',
+    day: 2,
+    checked: false,
+    schHoSta: '00:00',
+    schHoEnd: '00:00',
+    selected: false,
+    loading: false
+  },
+  {
+    name: 'Miércoles',
+    day: 3,
+    checked: false,
+    schHoSta: '00:00',
+    schHoEnd: '00:00',
+    selected: false,
+    loading: false
+  },
+  {
+    name: 'Jueves',
+    day: 4,
+    checked: false,
+    schHoSta: '00:00',
+    schHoEnd: '00:00',
+    selected: false,
+    loading: false
+  },
+  {
+    name: 'Viernes',
+    day: 5,
+    checked: false,
+    schHoSta: '00:00',
+    schHoEnd: '00:00',
+    selected: false,
+    loading: false
+  },
+  {
+    name: 'Sábado',
+    day: 6,
+    checked: false,
+    schHoSta: '00:00',
+    schHoEnd: '00:00',
+    selected: false,
+    loading: false
+  },
+  {
+    name: 'Domingo',
+    day: 0,
+    checked: false,
+    schHoSta: '00:00',
+    schHoEnd: '00:00',
+    selected: false,
+    loading: false
+  }
+]
+
+export const timeSuggestions = [
+  '00:00', '00:15', '00:30', '00:45', '01:00', '01:15', '01:30', '01:45',
+  '02:00', '02:15', '02:30', '02:45', '03:00', '03:15', '03:30', '03:45',
+  '04:00', '04:15', '04:30', '04:45', '05:00', '05:15', '05:30', '05:45',
+  '06:00', '06:15', '06:30', '06:45', '07:00', '07:15', '07:30', '07:45',
+  '08:00', '08:15', '08:30', '08:45', '09:00', '09:15', '09:30', '09:45',
+  '10:00', '10:15', '10:30', '10:45', '11:00', '11:15', '11:30', '11:45',
+  '12:00', '12:15', '12:30', '12:45', '13:00', '13:15', '13:30', '13:45',
+  '14:00', '14:15', '14:30', '14:45', '15:00', '15:15', '15:30', '15:45',
+  '16:00', '16:15', '16:30', '16:45', '17:00', '17:15', '17:30', '17:45',
+  '18:00', '18:15', '18:30', '18:45', '19:00', '19:15', '19:30', '19:45',
+  '20:00', '20:15', '20:30', '20:45', '21:00', '21:15', '21:30', '21:45',
+  '22:00', '22:15', '22:30', '22:45', '23:00', '23:15', '23:30', '23:45'
+]

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.ts

@@ -0,0 +1,195 @@
+import { useEffect, useState } from 'react'
+
+import { useFormatDate } from '../useFormatDate'
+
+import {
+  getDayFromOpeningKey,
+  getCurrentDayAndTime,
+  getOpeningKeyFromDay,
+  getTimeString,
+  sortOpeningsByDay,
+  weekDays,
+  timeToInt,
+  days,
+  getTimeObject
+} from './helpers'
+
+export const useStatusOpenStore = ({ dataSchedules = [] } = {}) => {
+  const [open, setOpen] = useState('')
+  const [openNow, setOpenNow] = useState(false)
+  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)
+    tomorrow.setDate(today.getDate() + 1)
+    const dayOfWeekTomorrow = tomorrow.getDay()
+
+    const findNextDay = dataSchedules?.length
+      ? dataSchedules?.some((schedule) => {return schedule?.schDay === dayOfWeekTomorrow})
+      : false
+
+    const findDataNextDay = dataSchedules?.length
+      ? 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',
+      'Monday',
+      'Tuesday',
+      'Wednesday',
+      'Thursday',
+      'Friday',
+      'Saturday'
+    ]
+
+    const ceroHours = '00:00 - 00:00'
+    let dayOfWeek = currentDayOfWeek
+
+    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) => {return item.trim()})
+
+      for (const span of timeSpans) {
+        const hours = span.split('-').map((item) => {return item.trim()})
+        const openTime = timeToInt(hours[0])
+        const closeTime = timeToInt(hours[1])
+
+        if (currentTime >= openTime && currentTime <= closeTime) {
+          return handleMessageHour(
+            'Abierto Ahora - Cierra a las: ' + handleHourPmAM(hours[1]),
+            true
+          )
+        }
+
+        if (currentTime < openTime && dayOfWeek === currentDayOfWeek) {
+          return handleMessageHour(
+            'Aun temprano - Abre hoy a las: ' + handleHourPmAM(hours[0]),
+            false
+          )
+        }
+
+        if (currentTime >= closeTime - 30 * 60000 && currentTime < closeTime && dayOfWeek === currentDayOfWeek) {
+          return handleMessageHour(
+            'Pronto por cerrar - Cierra hoy a las: ' + handleHourPmAM(hours[1]),
+            true
+          )
+        }
+
+        const {
+          findNextDay,
+          findDataNextDay,
+          dayOfWeekTomorrow
+        } = getNextDaySchedule(
+          dataSchedules,
+          currentDayOfWeek
+        )
+
+        if (findNextDay && findDataNextDay?.schHoSta) {
+          const nameOfDayTomorrow = weekDays[dayOfWeekTomorrow]
+          return handleMessageHour(
+            `Cerrado abre Mañana ${nameOfDayTomorrow} ${Boolean(findDataNextDay?.schHoSta) && 'a las'} ${
+              handleHourPmAM(findDataNextDay?.schHoSta) ?? ''
+            }`,
+            false
+          )
+        }
+
+        const nextDayName = weekDayLookup[(dayOfWeek + 1) % 7]
+        const nextOpening = openings?.['opening' + nextDayName.substring(0, 3)]
+        const nextHours = nextOpening?.split(';')?.map((item) => {return item?.trim()})
+
+        if (nextHours[0] !== ceroHours) {
+          return handleMessageHour(
+            'Cerrado - Abre el ' + days[nextDayName] + ' a las ' + nextHours[0],
+            false
+          )
+        }
+      }
+
+      dayOfWeek++
+    }
+
+    return handleMessageHour('Cerrado', false)
+  }
+
+  /**
+   *
+   * @param openings
+   */
+  function getIsOpening (openings) {
+    const { currentTime, currentDayOfWeek } = getCurrentDayAndTime()
+    return getOpeningStatus(openings, currentTime, currentDayOfWeek)
+  }
+
+  useEffect(() => {
+    (() => {
+      // Crear el objeto openings a partir del existStoreSchedule
+      const openings = {}
+      const existStoreSchedule = dataSchedules || []
+      existStoreSchedule?.forEach((schedule) => {
+        const day = schedule.schDay
+        const openingKey = getOpeningKeyFromDay(day)
+        const schHoSta = getTimeString(schedule?.schHoSta)
+        const schHoEnd = getTimeString(schedule?.schHoEnd)
+        openings[openingKey] = `${schHoSta} - ${schHoEnd}`
+      })
+
+      for (let i = 0; i < 7; i++) {
+        const openingKey = getOpeningKeyFromDay(i)
+        // eslint-disable-next-line no-prototype-builtins
+        if (!openings.hasOwnProperty(openingKey)) {
+          openings[openingKey] = '00:00 - 00:00' // Horario vacío para el día faltante
+        }
+      }
+
+      // Ejemplo de uso con el objeto proporcionado
+      const sortedOpenings = sortOpeningsByDay(openings)
+
+      // Crear el array completo con objetos de tiempo
+       
+      const fullArray = Object.keys(sortedOpenings).map((key) => {
+        const day = getDayFromOpeningKey(key)
+        const [schHoSta, schHoEnd] = openings[key].split(' - ').map(timeStr => {return getTimeObject(timeStr)})
+        return {
+          __typename: 'StoreSchedule',
+          schId: '',
+          idStore: '',
+          schDay: day,
+          schHoSta: `${schHoSta?.hours?.toString().padStart(2, '0')}:${schHoSta?.minutes?.toString().padStart(2, '0')}`,
+          schHoEnd: `${schHoEnd?.hours?.toString().padStart(2, '0')}:${schHoEnd?.minutes?.toString().padStart(2, '0')}`,
+          schState: 1
+        }
+      })
+      getIsOpening(sortedOpenings)
+    })()
+  }, [dataSchedules])
+
+  return {
+    open,
+    openNow
+  }
+}

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

@@ -0,0 +1,14 @@
+export const filterOrders = (orders = []) => {
+  const filteredOrders = orders?.filter((order) => {
+    if (order.pSState === 5) {
+      const tenMinutesAgo = new Date()
+      tenMinutesAgo.setMinutes(tenMinutesAgo.getMinutes() - 10)
+      const pDatMod = new Date(order.pDatMod)
+
+      return pDatMod > tenMinutesAgo
+    }
+    return true
+  })
+
+  return filteredOrders
+}