npm-pkg-hook 1.7.7 → 1.7.9

package/package.json

@@ -44,5 +44,5 @@
     "rm": "rm -rf node_modules package-lock.json && npm i",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "version": "1.7.7"
+  "version": "1.7.9"
 }

package/src/hooks/convertToMilitaryTime/index.js

@@ -0,0 +1,14 @@
+export function convertToMilitaryTime (time12Hour) {
+  const [time, period] = time12Hour.split(' ')
+  let [hours, minutes] = time.split(':')
+
+  if (period === 'PM' && hours !== '12') {
+    hours = String(Number(hours) + 12)
+  }
+
+  if (period === 'AM' && hours === '12') {
+    hours = '00'
+  }
+
+  return `${hours}:${minutes}`
+}

package/src/hooks/getTotalHours/index.js

@@ -0,0 +1,48 @@
+export const getTotalHours = (days) => {
+  const totalMinutesArray = days.map((day) => {
+    const { schHoSta, schHoEnd } = day
+
+    // Handle potential invalid time strings
+    if (!isValidTimeString(schHoSta) || !isValidTimeString(schHoEnd)) {
+      return 0 // Ignore invalid time strings and return 0
+    }
+
+    const [startHours, startMinutes] = schHoSta.split(':')
+    const [endHours, endMinutes] = schHoEnd.split(':')
+
+    // Convert hours and minutes to integers for calculations
+    let totalHoursInt = parseInt(endHours, 10) - parseInt(startHours, 10)
+    const totalMinutesInt = parseInt(endMinutes, 10) - parseInt(startMinutes, 10)
+
+    // Handle negative total minutes (occurs when endMinutes < startMinutes)
+    let totalMinutes = totalMinutesInt
+    if (totalMinutes < 0) {
+      totalHoursInt-- // Decrement total hours for negative minutes
+      totalMinutes += 60 // Add 60 minutes to account for borrowing from previous hour
+    }
+
+    // Calculate total time in minutes
+    const totalTimeMinutes = totalHoursInt * 60 + totalMinutes
+
+    return totalTimeMinutes
+  })
+
+  // Calculate the sum of total minutes for all days
+  const totalMinutes = totalMinutesArray.reduce((acc, curr) => acc + curr, 0)
+
+  // Convert total minutes to hours and minutes format
+  const totalHours = Math.floor(totalMinutes / 60)
+  const remainingMinutes = totalMinutes % 60
+
+  // Format the total time as "00:00"
+  const formattedHours = totalHours.toString().padStart(2, '0')
+  const formattedMinutes = remainingMinutes.toString().padStart(2, '0')
+
+  return `${formattedHours}:${formattedMinutes}`
+}
+
+// Function to validate time string format (HH:MM)
+export const isValidTimeString = (timeString) => {
+  const timeRegex = /^([0-1][0-9]|2[0-3]):([0-5][0-9])$/
+  return timeRegex.test(timeString)
+}

package/src/hooks/index.js

@@ -6,6 +6,8 @@ export * from './useCategoryStore'
 export * from './useCatWithProduct'
 export * from './useManageQueryParams'
 export * from './useDeliveryTime'
+export * from './getTotalHours'
+export * from './convertToMilitaryTime'
 export * from './statusOpenStores'
 export * from './completeSchedules'
 export * from './useLogout/helpers/BroadcastChannel'
@@ -15,6 +17,8 @@ export * from './useCreateDeliveryTime'
 export * from './addTenMinutes'
 export * from './useCategoriesProduct'
 export * from './useLogout'
+export * from './useSetupSchedule'
+export * from './useMouse'
 export * from './useStatusOpenStore'
 export * from './usePushNotificationOrder'
 export * from './newStoreOrderSubscription'

package/src/hooks/useMouse/index.ts

@@ -0,0 +1,51 @@
+import { useEffect, useRef, useState } from "react";
+import type { MouseEvent } from "react";
+
+export function useMouse<T extends HTMLElement = any>(
+  options: { resetOnExit?: boolean } = { resetOnExit: false }
+) {
+  const [position, setPosition] = useState({ x: 0, y: 0 });
+
+  const ref = useRef<T>();
+
+  const setMousePosition = (event: MouseEvent<HTMLElement>) => {
+    if (ref.current) {
+      const rect = event.currentTarget.getBoundingClientRect();
+
+      const x = Math.max(
+        0,
+        Math.round(
+          event.pageX - rect.left - (window.pageXOffset || window.scrollX)
+        )
+      );
+
+      const y = Math.max(
+        0,
+        Math.round(
+          event.pageY - rect.top - (window.pageYOffset || window.scrollY)
+        )
+      );
+
+      setPosition({ x, y });
+    } else {
+      setPosition({ x: event.clientX, y: event.clientY });
+    }
+  };
+
+  const resetMousePosition = () => setPosition({ x: 0, y: 0 });
+
+  useEffect(() => {
+    const element = ref?.current ? ref.current : document;
+    element.addEventListener("mousemove", setMousePosition as any);
+    if (options.resetOnExit)
+      element.addEventListener("mouseleave", resetMousePosition as any);
+
+    return () => {
+      element.removeEventListener("mousemove", setMousePosition as any);
+      if (options.resetOnExit)
+        element.removeEventListener("mouseleave", resetMousePosition as any);
+    };
+  }, [ref.current]);
+
+  return { ref, ...position };
+}

package/src/hooks/useSchedule/index.js

@@ -51,12 +51,18 @@ export const useSetScheduleOpenAll = () => {
   return [handleSetStoreSchedule, { loading, error }]
 }
 
-export const useSchedules = ({ schDay = 1, idStore = '' }) => {
+export const useSchedules = ({ schDay = 1, idStore = '', onCompleted = (data) => { return data } }) => {
   const {
     data,
     loading,
     error
-  } = useQuery(GET_SCHEDULE_STORE, { variables: { schDay, idStore } })
+  } = useQuery(GET_SCHEDULE_STORE, {
+    variables: { schDay, idStore },
+    onCompleted: (data) => {
+      onCompleted(data)
+    }
+  }
+  )
 
   return [data?.getStoreSchedules, { loading, error }]
 }

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

@@ -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.js

@@ -0,0 +1,230 @@
+import { useEffect, useState } from 'react'
+import { dateEnum, initialDays, timeSuggestions } from './helpers'
+import { useCreateSchedules, useSchedules } from '../useSchedule'
+import { days as NameDays } from '../../utils'
+import { convertToMilitaryTime } from '../convertToMilitaryTime'
+import { GET_ONE_SCHEDULE_STORE, GET_SCHEDULE_STORE } from '../useSchedule/queries'
+export * from './helpers/index'
+
+export const useSetupSchedule = ({
+  idStore = null, sendNotification = (args) => {
+    return args
+  }
+} = {}) => {
+  const [days, setDays] = useState(initialDays)
+  const [alertModal, setAlertModal] = useState(false)
+  const [selectedDay, setSelectedDay] = useState({})
+  const [setStoreSchedule, { loading }] = useCreateSchedules()
+
+  const onCompleted = (data) => {
+    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) => ({
+        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 => 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 => 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) => 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 }
+      } else {
+        return { ...d }
+      }
+    })
+    setDays(updatedDays)
+  }
+  const selectedDays = days?.filter((day) => Boolean(day.selected)).map((day) => {
+    return day.day
+  })
+
+  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) }
+        } else {
+          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)
+        // Comparar solo las horas y minutos
+        if (startHour === endHour) {
+          // eslint-disable-next-line consistent-return
+          sendNotification({
+            description: 'Error, la hora de salida no debe ser igual a la hora final',
+            title: 'Error',
+            backgroundColor: 'error'
+          })
+        }
+        if (startHour > endHour) {
+          // eslint-disable-next-line consistent-return
+          sendNotification({
+            description: 'Error, la hora de salida debe ser mayor que la de entrada',
+            title: 'Error',
+            backgroundColor: 'error'
+          })
+        }
+        if (startHour !== endHour && 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 }
+          } else {
+            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 => {
+      const updatedDays = prevDays.map((d) => {
+        if (d.day === day) {
+          return {
+            ...d,
+            [dateEnum.schHoEnd]: dateEnum.schHoEnd,
+            [dateEnum.schHoSta]: dateEnum.schHoSta,
+            selected: false
+          }
+        } else {
+          return { ...d }
+        }
+      })
+      return updatedDays
+    })
+    setAlertModal(false)
+  }
+  useEffect(() => {
+    onCompleted(data)
+  }, [data])
+
+  return {
+    duplicateDay,
+    alertModal,
+    toggleCheck,
+    handleSelectedDay,
+    onChangeSaveHour,
+    handleDeleteSchedule,
+    setAlertModal,
+    days,
+    selectedDays,
+    selectedDay,
+    loading: lsc || loading,
+    times: timeSuggestions
+  }
+}

package/src/utils/index.js

@@ -164,6 +164,16 @@ export const SPANISH_MONTHS = {
   11: 'Diciembre'
 }
 
+export const days = {
+  1: 'Lunes',
+  2: 'Martes',
+  3: 'Miércoles',
+  4: 'Jueves',
+  5: 'Viernes',
+  6: 'Sábado',
+  0: 'Domingo'
+}
+
 export const convertBase64 = file => {
   return new Promise((resolve, reject) => {
     const reader = new FileReader()