npm-pkg-hook 1.12.3 → 1.12.7

package/src/hooks/useSetupSchedule/index.js

@@ -1,272 +0,0 @@
-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 === null ? [] : 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
-  })
-  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
-  }
-  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) }
-        } 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)
-        if (isLessThanOneHour(startHour, endHour)) {
-          // eslint-disable-next-line consistent-return
-          sendNotification({
-            description: 'Error, el horario debe ser mayor a una hora',
-            title: 'Error',
-            backgroundColor: 'error'
-          })
-        }
-        // 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 && !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 }
-          } 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 => {
-      if (!prevDays) return []
-      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,
-    toggleCheck,
-    handleSelectedDay,
-    onChangeSaveHour,
-    handleDeleteSchedule,
-    setAlertModal,
-    days,
-    selectedDays,
-    selectedDay,
-    alertModal,
-    loading: lsc || loading,
-    times: timeSuggestions
-  }
-}

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

@@ -1,101 +0,0 @@
-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
-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 {
-
-    }
-  }
-}
-
-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 => parseInt(str))
-    return { hours, minutes }
-  } catch (e) {
-    return { hours: 0, minutes: 0 } // Return default values on error
-  }
-}
-
-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
-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'
-]
-
-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

@@ -1,179 +0,0 @@
-import { useEffect, useState } from 'react'
-import {
-  getDayFromOpeningKey,
-  getCurrentDayAndTime,
-  getOpeningKeyFromDay,
-  getTimeString,
-  sortOpeningsByDay,
-  weekDays,
-  timeToInt,
-  days,
-  getTimeObject
-} from './helpers'
-import { useFormatDate } from '../useFormatDate'
-import { convertToMilitaryTime } from '../convertToMilitaryTime'
-
-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)
-  }
-
-  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) => schedule?.schDay === dayOfWeekTomorrow)
-      : false
-
-    const findDataNextDay = dataSchedules?.length
-      ? dataSchedules?.find((schedule) => schedule?.schDay === dayOfWeekTomorrow)
-      : {}
-
-    return { findNextDay, findDataNextDay, dayOfWeekTomorrow }
-  }
-
-  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) => item.trim())
-
-      for (const span of timeSpans) {
-        const hours = span.split('-').map((item) => 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} ${!!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) => item?.trim())
-
-        if (nextHours[0] !== ceroHours) {
-          return handleMessageHour(
-            'Cerrado - Abre el ' + days[nextDayName] + ' a las ' + nextHours[0],
-            false
-          )
-        }
-      }
-
-      dayOfWeek++
-    }
-
-    return handleMessageHour('Cerrado', false)
-  }
-
-  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
-      // 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))
-        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.js

@@ -1,14 +0,0 @@
-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
-}

package/src/hooks/useStatusOrdersClient/index.js

@@ -1,17 +0,0 @@
-import { useQuery } from '@apollo/client'
-import { GET_ALL_PEDIDOS_STATUS } from './queries'
-import { filterOrders } from './helpers'
-
-export const useStatusOrdersClient = () => {
-  const { data, loading, error } = useQuery(GET_ALL_PEDIDOS_STATUS, {
-    pollInterval: 60000,
-    fetchPolicy: 'cache-and-network',
-    onError: () => {}
-  })
-
-  return {
-    data: loading ? [] : filterOrders(data?.getAllPedidoUserFinal || []),
-    loading,
-    error
-  }
-}

package/src/hooks/useStatusOrdersClient/queries.js

@@ -1,80 +0,0 @@
-import { gql } from '@apollo/client'
-
-export const GET_ALL_PEDIDOS_STATUS = gql`
-  query getAllPedidoUserFinal($id: ID) {
-    getAllPedidoUserFinal(id: $id) {
-      pdpId
-      idStore
-      pCodeRef
-      payMethodPState
-      pPRecoger
-      totalProductsPrice
-      pSState
-      getOneStore {
-        idStore
-        cId
-        id
-        dId
-        ctId
-        neighborhoodStore
-        Viaprincipal
-        storeOwner
-        storeName
-        emailStore
-        storePhone
-        Image
-        pais {
-          cId
-          cName
-        }
-        city {
-          ctId
-          cName
-          dId
-        }
-        department {
-          dId
-          cId
-          dName
-        }
-      }
-      pDatCre
-      locationUser
-      pDatMod
-      getAllPedidoStore {
-        pdpId
-        pId
-        idStore
-        ShoppingCard
-        pCodeRef
-        pPStateP
-        payMethodPState
-        pPRecoger
-        pDatCre
-        pDatMod
-        getAllShoppingCard {
-          ShoppingCard
-          comments
-          cantProducts
-          pId
-          productFood {
-            pId
-            carProId
-            colorId
-            idStore
-            pName
-            ProPrice
-            ProDescuento
-            ProDescription
-            ValueDelivery
-            ProImage
-            ProStar
-            pState
-            pDatCre
-            pDatMod
-          }
-        }
-      }
-    }
-  }
-`

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

@@ -1,16 +0,0 @@
-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 => item.date === formattedDate)
-
-    filledData.push(existingData || { date: formattedDate, TotalIn: 0, TotalOut: 0, TotalAdjustment: 0 })
-  }
-
-  return filledData
-}