npm-pkg-hook 1.0.9 → 1.1.2

package/src/hooks/useSales/useGetAllSales/index.js

@@ -0,0 +1,25 @@
+import { useQuery } from '@apollo/client';
+import { GET_ALL_SALES_STATISTICS } from '../queries';
+
+export const useGetAllSales = ({ 
+  fromDate = '',
+  toDate = ''
+} = {}) => {
+  const { 
+    data, 
+    loading, 
+    error
+  } = useQuery(GET_ALL_SALES_STATISTICS, {
+    fetchPolicy: 'cache-first',
+    variables: {
+      fromDate,
+      toDate,
+    },
+  });
+
+  return {
+    data: data?.getAllSalesStoreStatistic || [],
+    error,
+    loading
+  };
+};

package/src/hooks/useSales/useGetSale.js

@@ -1,8 +1,22 @@
 import { useLazyQuery } from '@apollo/client'
 import { GET_ONE_SALE } from './queries'
 
-export const useGetSale = () => {
-  const [getOnePedidoStore, { loading, data, called, error }] = useLazyQuery(GET_ONE_SALE)
+export const useGetSale = ({ callback = () => { return } } = {}) => {
+  const [getOnePedidoStore, { 
+    loading, 
+    data, 
+    called, 
+    error
+  }] = useLazyQuery(GET_ONE_SALE, {
+    onCompleted: (res) => {
+      if (res?.getOnePedidoStore) {
+        return callback(res)
+      }
+    },
+    onError: () => {
+      return callback(null)
+    }
+  })
   return {
     data: data?.getOnePedidoStore, // actualizado aquí
     loading,

package/src/hooks/useSchedule/index.js

@@ -0,0 +1,36 @@
+import { useQuery, useMutation } from '@apollo/client'
+import { GET_ONE_SCHEDULE_STORE, GET_SCHEDULE_STORE, CREATE_STORE_CALENDAR } from './queries'
+export { GET_ONE_SCHEDULE_STORE, GET_SCHEDULE_STORE, CREATE_STORE_CALENDAR } from './queries'
+
+export const useSchedule = ({ day = null }) => {
+  const {
+    data,
+    loading,
+    error
+  } = useQuery(GET_ONE_SCHEDULE_STORE, { variables: { schDay: day } })
+
+  return [data?.getOneStoreSchedules, { loading, error }]
+}
+
+export const useSchedules = ({ schDay = 1 }) => {
+  const {
+    data,
+    loading,
+    error
+  } = useQuery(GET_SCHEDULE_STORE, { variables: { schDay: schDay } })
+
+
+  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.js

@@ -0,0 +1,35 @@
+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
+    }
+  }
+`;
+

package/src/hooks/useScheduleData/index.js

@@ -0,0 +1,171 @@
+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) => item.schDay === dayObj.day);
+        return originalObj ? 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} Duración en horas con dos decimales.
+     */
+
+  // Función para calcular la duración en horas de un horario
+  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
+    let columnIndex = 0;
+    let lastDay = -1;
+    const uniqueHoursSet = new Set([
+        ...combinedArray.map((item) => item.schHoSta),
+        ...combinedArray.map((item) => 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 = 100;
+    const daysWithHours = Array.from(new Set(combinedArray.map((item) => (item.schDay !== undefined ? item.schDay : item.day))));
+    const totalDays = daysWithHours.length;
+    const totalWidth = totalDays * dayWidth;
+    const MINUTES_THRESHOLDS = [1, 2, 3, 4, 5, 15, 30]; // Define los umbrales de minutos para agrupar
+
+    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 groupedHours = [];
+    let currentGroup = [sortedUniqueHours[0]];
+    
+    for (let i = 1; i < sortedUniqueHours.length; i++) {
+      const prevTime = new Date(`2023-08-01 ${sortedUniqueHours[i - 1]}`);
+      const currentTime = new Date(`2023-08-01 ${sortedUniqueHours[i]}`);
+      const timeDifference = (currentTime - prevTime) / (1000 * 60);
+    
+      let shouldGroup = false;
+    
+      for (const threshold of MINUTES_THRESHOLDS) {
+        if (timeDifference <= threshold) {
+          shouldGroup = true;
+          break;
+        }
+      }
+    
+      if (shouldGroup) {
+        currentGroup.push(sortedUniqueHours[i]);
+      } else {
+        if (currentGroup.length > 2) {
+          groupedHours.push(currentGroup.join(' - '));
+        } else {
+          groupedHours.push(...currentGroup);
+        }
+        currentGroup = [sortedUniqueHours[i]];
+      }
+    }
+    
+    if (currentGroup.length > 2) {
+      groupedHours.push(currentGroup.join(' - '));
+    } else {
+      groupedHours.push(...currentGroup);
+    }
+    
+    const combinedHours = groupedHours.reduce((acc, group) => {
+      if (group.includes('-')) {
+        acc.push(group);
+      } else {
+        acc.push(...group.split(' - '));
+      }
+      return acc;
+    }, []);
+    
+    const formattedHours = combinedHours;
+    
+    
+  function calculateTimeLinesHeight() {
+    const totalHours = uniqueHours.length;
+    return totalHours * 60; // Cada hora ocupa 60 píxeles de altura
+}
+    return {
+        columnIndex,
+        combinedArray: combinedArray,
+        days,
+        daysArray,
+        daysWithHours,
+        dayWidth,
+        lastDay,
+        totalWidth,
+        sortedUniqueHours,
+        uniqueHours: formattedHours,
+        calculateDurationInHours,
+        calculateTimeLinesHeight,
+        calculateYPosition
+    };
+}

package/src/hooks/useScroll/index.js

@@ -0,0 +1,57 @@
+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.js

@@ -0,0 +1,14 @@
+// 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/useStatusOpenStore/helpers/index.js

@@ -0,0 +1,102 @@
+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) {
+    let hour = parseInt(text.substring(0, 2));
+    let 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

@@ -0,0 +1,173 @@
+import { useEffect, useState } from 'react'
+import {
+    getDayFromOpeningKey,
+    getCurrentDayAndTime,
+    getOpeningKeyFromDay,
+    getTimeString,
+    sortOpeningsByDay,
+    weekDays,
+    timeToInt,
+    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 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 (let 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 - Mañana ${nameOfDayTomorrow} ${!!findDataNextDay?.schHoSta && 'a las'} ${
+                  !!findDataNextDay?.schHoSta ? 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());
+      
+            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);
+                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 => 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
+    }
+}