npm-pkg-hook 1.3.8 → 1.4.0

package/src/hooks/useDownloadReports/useDownloadReportByDay/index.ts

@@ -0,0 +1,105 @@
+import { useLazyQuery } from '@apollo/client'
+import { gql } from '@apollo/client'
+import { useState } from 'react'
+
+import { downloadFileFromResponse } from '../helpers/downloadFileFromResponse'
+
+
+/**
+ * GraphQL query to get the report for a specific day.
+ */
+const GET_REPORT_DAY_NUMBER = gql`
+  query getReportDayNumber($day: Int!) {
+    getReportDayNumber(day: $day) {
+      success
+      message
+      errors {
+        path
+        message
+        type
+      }
+      data {
+        id
+        name
+        description
+        url
+        createdAt
+      }
+    }
+  }
+`
+
+/**
+ * Custom hook to trigger the report download when the GraphQL query resolves.
+ *
+ * @param root0
+ * @param root0.sendNotification
+ * @returns {{
+ *   downloadReport: (day: number) => void,
+ *   loading: boolean,
+ *   error: Error | undefined
+ * }} Object containing the trigger function, loading state and error.
+ */
+export const useDownloadReportByDay = ({
+  sendNotification = (
+    { description = '', title = '', backgroundColor = 'info' } = {}
+  ) => {
+    return {
+      description,
+      title,
+      backgroundColor
+    }
+  }
+} = {}) => {
+  const [finished, setFinished] = useState(false)
+  const [fetchReport, { loading, error }] = useLazyQuery(GET_REPORT_DAY_NUMBER, {
+    fetchPolicy: 'network-only',
+    onCompleted: async ({ getReportDayNumber }) => {
+      setFinished(false)
+      try {
+        const {
+          success,
+          data,
+          message
+        } = getReportDayNumber || {}
+        if (!success || !data) {
+          setFinished(true)
+          return sendNotification({
+            description: message,
+            title: 'Error al descargar reporte',
+            backgroundColor: 'error'
+          })
+        }
+        const { url = '', name = '' } = data
+        const response = await fetch(`/api/files/${encodeURIComponent(url)}`)
+        await downloadFileFromResponse(response, name)
+        setFinished(true)
+        return sendNotification({
+          description: message ?? 'Reporte descargado exitosamente',
+          title: 'Reporte descargado',
+          backgroundColor: 'success'
+        })
+      } catch (e) {
+        setFinished(false)
+      }
+    },
+    onError: () => {
+      setFinished(true)
+    }
+  })
+
+  /**
+   * Triggers the report download process.
+   * @param {number} day - The report day number to fetch.
+   */
+  const downloadReport = (day: number) => {
+    setFinished(false)
+    if (!day || typeof day !== 'number') {
+      console.warn('Invalid day for report download')
+      return
+    }
+    fetchReport({ variables: { day } })
+  }
+
+  return [downloadReport, { loading, error, finished }] as const
+}

package/src/hooks/useDownloadReports/useGetReportByDateRange/index.ts

@@ -0,0 +1,116 @@
+import { useLazyQuery } from '@apollo/client'
+import { gql } from '@apollo/client'
+import { useState } from 'react'
+
+import { downloadFileFromResponse } from '../helpers/downloadFileFromResponse'
+
+/**
+ * GraphQL query to get report by date range
+ */
+const GET_REPORT_BY_DATE_RANGE = gql`
+  query getReportByDateRange($startDate: DateTime!, $endDate: DateTime!) {
+    getReportBydateRange(startDate: $startDate, endDate: $endDate) {
+      success
+      message
+      errors {
+        path
+        message
+        type
+      }
+      data {
+        id
+        name
+        description
+        url
+        createdAt
+      }
+    }
+  }
+`
+
+/**
+ * Custom hook to fetch report by a date range
+ * @param {Object} options
+ * @param {Function} options.sendNotification - Function to notify user
+ * @returns {[Function, { loading: boolean, error: any, data: any }]}
+ */
+export const useGetReportByDateRange = ({
+  sendNotification = ({ description = '', title = '', backgroundColor = 'info' } = {}) => {
+    return { description, title, backgroundColor }
+  }
+} = {}) => {
+  const [loading, setLoading] = useState(false)
+  const [finished, setFinished] = useState(false)
+
+  const [getReportQuery, { data, error }] = useLazyQuery(GET_REPORT_BY_DATE_RANGE, {
+    onCompleted: () => {
+      setFinished(true)
+    }
+  })
+
+  /**
+   * Triggers the report generation and handles download
+   * @param {string} startDate - Start date in YYYY-MM-DD format
+   * @param {string} endDate - End date in YYYY-MM-DD format
+   * @returns {Promise<any>}
+   */
+  const getReport = async (startDate, endDate) => {
+    try {
+      setLoading(true)
+      const response = await getReportQuery({
+        variables: { startDate, endDate },
+        fetchPolicy: 'network-only'
+      })
+
+      const reportResult = response?.data?.getReportBydateRange ?? {
+        success: false,
+        message: 'No report data found',
+        data: null
+      }
+
+      if (!reportResult) {
+        setLoading(false)
+        return {
+          success: false,
+          message: 'No report data found',
+          data: null
+        }
+      }
+
+      const {
+        success,
+        message,
+        data
+      } = reportResult
+
+      sendNotification({
+        description: message,
+        title: success ? 'Success' : 'Error',
+        backgroundColor: success ? 'success' : 'error'
+      })
+
+      if (success && data?.url && data?.name) {
+        setLoading(true)
+        const res = await fetch(`/api/files/${encodeURIComponent(data.url)}`)
+        await downloadFileFromResponse(res, data.name)
+        setLoading(false)
+      }
+      return reportResult
+    } catch (err) {
+      setLoading(false)
+      sendNotification({
+        description: err.message || 'Unexpected error',
+        title: 'Error',
+        backgroundColor: 'error'
+      })
+      return { success: false, message: err.message, data: null }
+    }
+  }
+
+  return [getReport, {
+    loading,
+    error,
+    finished,
+    data: data?.getReportBydateRange
+  }]
+}

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

@@ -1,5 +1,9 @@
 import { useEffect, useState } from 'react'
 
+/**
+ *
+ * @param ref
+ */
 export function useDrag2 (ref) {
   useEffect(() => {
     if (!ref || !ref?.current) return null
@@ -8,18 +12,30 @@ export function useDrag2 (ref) {
     const previousOffset = { x: 0, y: 0 }
     let originMouseX
     let originMouseY
+    /**
+     *
+     * @param e
+     */
     function onMousemove (e) {
       const { pageX, pageY } = e
       const x = pageX - originMouseX + previousOffset.x
       const y = pageY - originMouseY + previousOffset.y
       target.style.transform = `translate(${x}px, ${y}px)`
     }
+    /**
+     *
+     * @param e
+     */
     function onMouseup (e) {
       previousOffset.x += e.pageX - originMouseX
       previousOffset.y += e.pageY - originMouseY
       window.removeEventListener('mousemove', onMousemove)
       window.removeEventListener('mouseup', onMouseup)
     }
+    /**
+     *
+     * @param e
+     */
     function onMousedown (e) {
       originMouseX = e.pageX
       originMouseY = e.pageY

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

@@ -43,12 +43,12 @@ export const useDropzone = (
     },
     dragleave: e => {
       return handle.body.dragLeave(e, () => {
-      // eslint-disable-next-line
+       
               if (isDragging) setDragging(false)
       })
     },
     dragend: () => {
-      // eslint-disable-next-line
+       
           },
     drop: e => {
       return handle.body.drop(e, () => {

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

@@ -1,5 +1,6 @@
 import { useQuery } from '@apollo/client'
-import { useState } from 'react'
+import { useState } from 'react'
+
 import { GET_ONE_DYNAMIC_PASS } from './queries'
 
 export const useDynamicAuth = () => {

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

@@ -1,4 +1,4 @@
-import { gql, useMutation } from '@apollo/client';
+import { gql, useMutation } from '@apollo/client'
 
 const EDIT_CATEGORY_PRODUCT = gql`
   mutation EditOneCategoryProduct($pName: String!, $ProDescription: String, $carProId: ID!) {
@@ -7,35 +7,35 @@ const EDIT_CATEGORY_PRODUCT = gql`
       message
     }
   }
-`;
+`
 
-export const useEditCategoryProduct = ({ sendNotification = () => { return } } = {}) => {
-  const [editCategoryProductMutation] = useMutation(EDIT_CATEGORY_PRODUCT);
+export const useEditCategoryProduct = ({ sendNotification = () => { } } = {}) => {
+  const [editCategoryProductMutation] = useMutation(EDIT_CATEGORY_PRODUCT)
 
   const editCategoryProduct = async (pName, ProDescription, carProId) => {
     try {
       const { data } = await editCategoryProductMutation({
         variables: { pName, ProDescription, carProId }
-      });
+      })
 
       if (data.editOneCategoryProduct.success) {
         return {
           success: true,
           message: 'Categoría de producto editada correctamente'
-        };
-      } else {
-        return {
-          success: false,
-          message: data.editOneCategoryProduct.message || 'Error al editar la categoría de producto'
-        };
+        }
+      } 
+      return {
+        success: false,
+        message: data.editOneCategoryProduct.message || 'Error al editar la categoría de producto'
       }
+      
     } catch (error) {
       return {
         success: false,
         message: error.message || 'Error al editar la categoría de producto'
-      };
+      }
     }
-  };
+  }
 
   return { editCategoryProduct }
-};
+}

package/src/hooks/useEditOneExtProductFoodOptional/index.ts

@@ -0,0 +1,28 @@
+import { useMutation } from '@apollo/client'
+import { useState } from 'react'
+
+import { UPDATE_EXT_PRODUCT_FOOD_OPTIONAL } from './queries'
+export const useEditOneExtProductFoodOptional = () => {
+  const [updateExtProductFood] = useMutation(UPDATE_EXT_PRODUCT_FOOD_OPTIONAL)
+  const [loading, setLoading] = useState(false)
+
+  const updateOneExtraProductFood = async (input) => {
+    setLoading(true)
+
+    try {
+      const { data } = await updateExtProductFood({
+        variables: { input }
+      })
+      console.log('Product food updated:', data.editExtProductFoodOptional)
+      setLoading(false)
+    } catch (error) {
+      console.error('Error updating product food:', error.message)
+      setLoading(false)
+      throw new Error('Error updating product food')
+    }
+  }
+  return {
+    loading,
+    updateOneExtraProductFood
+  }
+}

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

@@ -1,4 +1,4 @@
-import { gql } from "@apollo/client"
+import { gql } from '@apollo/client'
 
 export const UPDATE_EXT_PRODUCT_FOOD_OPTIONAL = gql`
 mutation editExtProductFoodOptional($input: EditExtProductFoodOptionalInput!) {
@@ -13,4 +13,4 @@ mutation editExtProductFoodOptional($input: EditExtProductFoodOptionalInput!) {
       pDatMod
     }
   }
-`
+`

package/src/hooks/useEditSubProductOptional/index.ts

@@ -0,0 +1,12 @@
+import { useMutation } from '@apollo/client'
+
+import { EDIT_EXTRA_SUB_OPTIONAL_PRODUCTS } from './queries'
+
+export const useEditSubProductOptional = () => {
+  const [editExtFoodSubsOptional, {
+    loading,
+    error,
+    called
+  }] = useMutation(EDIT_EXTRA_SUB_OPTIONAL_PRODUCTS)
+  return [editExtFoodSubsOptional, { loading, error, called }]
+}

package/src/hooks/useEmployee/index.ts

@@ -0,0 +1,18 @@
+import { useQuery } from '@apollo/client'
+
+import { GET_EMPLOYEES } from './queries'
+
+export const useEmployee = () => {
+  const {
+    data,
+    loading,
+    error,
+    fetchMore
+  } = useQuery(GET_EMPLOYEES)
+  return [data?.employees?.data ?? [], {
+    loading,
+    error,
+    fetchMore,
+    pagination: data?.employees?.pagination ?? {}
+  }]
+}

package/src/hooks/useEmployee/queries.ts

@@ -0,0 +1,85 @@
+import { gql } from '@apollo/client'
+
+export const GET_EMPLOYEES = gql`
+query employees {
+  employees {
+    data {
+        eId
+        idStore
+        idRole
+        eEmail
+        eState
+        status
+      user {
+        id
+        name
+        username
+        lastName
+        email
+        avatar
+        uToken
+        uPhoNum
+        ULocation
+        upLat
+        uState
+        upLon
+        upIdeDoc
+        siteWeb
+        description
+        createAt
+        associateStore
+      }
+      roles {
+        idRole
+name
+priority
+description
+permissions
+createdAt
+updatedAt
+      }
+    }
+    success
+    message
+ pagination {
+      totalRecords
+      totalPages
+      currentPage
+    }
+    errors {
+      path
+      message
+      type
+      context {
+        limit
+        value
+        label
+        key
+      }
+    }
+    
+  }
+}
+`
+/**
+ * GraphQL mutation for creating an employee, store, and user.
+ */
+export const CREATE_ONE_EMPLOYEE_STORE_AND_USER = gql`
+  mutation createOneEmployeeStoreAndUser($input: IEmployeeStore!) {
+    createOneEmployeeStoreAndUser(input: $input) {
+      success
+      message
+      errors {
+        path
+        message
+        type
+        context {
+          limit
+          value
+          label
+          key
+        }
+      }
+    }
+  }
+`

package/src/hooks/useEmployee/useCreateEmployee.ts

@@ -0,0 +1,90 @@
+import { useMutation } from '@apollo/client'
+import { useState } from 'react'
+
+import { CREATE_ONE_EMPLOYEE_STORE_AND_USER } from './queries'
+
+/**
+ * Custom hook to handle the createOneEmployeeStoreAndUser mutation.
+ *
+ * @param root0
+ * @param {Object}
+ * @param root0.sendNotification
+ * @param root0.onCompleted
+ * @param root0.onError
+ * @returns {{
+ *   createEmployeeStoreAndUser: (input: IEmployeeStore) => Promise<void>,
+ *   loading: boolean,
+ *   error: Error | null,
+ *   data: Object | null
+ * }} An object containing the mutation function, loading status, error, and data.
+ */
+export const useCreateEmployeeStoreAndUser = ({
+  sendNotification = () => {
+    return {
+      description: '',
+      title: '',
+      backgroundColor: ''
+    }
+  },
+  onCompleted = () => {
+    return {
+    }
+  },
+  onError = () => {
+    return {
+    }
+  }
+} = {}) => {
+  const [createEmployeeStoreAndUserMutation, { loading, error, data }] = useMutation(CREATE_ONE_EMPLOYEE_STORE_AND_USER, {
+    onError: () => {
+      sendNotification({
+        description: 'Error creando empleado',
+        title: 'Error',
+        backgroundColor: 'error'
+      })
+    },
+    onCompleted: (response) => {
+      console.log(response)
+      const { createOneEmployeeStoreAndUser } = response ?? {}
+      const { message, success } = createOneEmployeeStoreAndUser ?? {}
+      if (success === false) {
+        onError(response)
+      }
+      if (success) {
+        onCompleted(response)
+      }
+      sendNotification({
+        description: message,
+        title: success ? 'Exito' : 'Error',
+        backgroundColor: success ? 'success' : 'error'
+      })
+    }
+  })
+  const [errors, setErrors] = useState([])
+
+  /**
+   * Calls the createOneEmployeeStoreAndUser mutation.
+   *
+   * @param {Object} input - The input data for the mutation.
+   * @returns {Promise<void>}
+   */
+  const createEmployeeStoreAndUser = async (input) => {
+    try {
+      const response = await createEmployeeStoreAndUserMutation({ variables: { input } })
+      if (response.data.createOneEmployeeStoreAndUser.errors) {
+        setErrors(response.data.createOneEmployeeStoreAndUser.errors)
+      } else {
+        setErrors([])
+      }
+    } catch (err) {
+      setErrors([{ message: err.message }])
+    }
+  }
+
+  return [createEmployeeStoreAndUser, {
+    loading,
+    error,
+    data,
+    errors
+  }]
+}

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

@@ -1,4 +1,5 @@
 import { useEffect } from 'react'
+
 export const on = ({ eventType, callBack }) => {
   document.addEventListener(eventType, callBack)
 }

package/src/hooks/useFavoriteStores/index.ts

@@ -0,0 +1,31 @@
+import { useQuery } from '@apollo/client'
+
+import { filterAndSortByDate } from '../useRestaurant/helpers'
+import { getStatusForStores } from '../useRestaurant/helpers/manageStatusOpen'
+
+import { GET_ALL_FAV_STORE } from './queries'
+
+export const useFavoriteStores = () => {
+  const {
+    data,
+    loading,
+    error
+  } = useQuery(GET_ALL_FAV_STORE, {
+    fetchPolicy: 'cache-and-network',
+    onError: () => {
+      console.log('')
+    }
+  })
+  const newArray = data?.getFavorite?.map(store => {
+    return {
+      ...store.getOneStore
+    }
+  }) || []
+  const dataSort = filterAndSortByDate(newArray)
+
+  const statuses = getStatusForStores(dataSort)
+
+  const favoriteStores = statuses || []
+
+  return [loading ? [] : favoriteStores, { loading, error }]
+}

package/src/hooks/useFavoriteStores/queries.ts

@@ -0,0 +1,54 @@
+import { gql } from '@apollo/client'
+
+export const GET_ALL_FAV_STORE = gql`
+  query getFavorite {
+    getFavorite {
+      fIStoreId
+      fState
+      createAt
+      updateAt
+      idStore
+
+      getOneStore {
+        getStoreSchedules {
+          schId
+          idStore
+          schDay
+          schHoSta
+          schHoEnd
+          schState
+        }
+        deliveryTimeMinutes
+        scheduleOpenAll
+        idStore
+        cId
+        id
+        Image
+        open
+        cateStore {
+          catStore
+          cName
+        }
+        ctId
+        catStore
+        dId
+        storeName
+        Image
+        city {
+          ctId
+          dId
+          cName
+        }
+        department {
+          dId
+          cId
+          dName
+        }
+        pais {
+          cId
+          cName
+        }
+      }
+    }
+  }
+`