npm-pkg-hook 1.12.7 → 1.12.8

package/src/hooks/useStatusOrdersClient/index.ts

@@ -0,0 +1,18 @@
+import { useQuery } from '@apollo/client'
+
+import { filterOrders } from './helpers'
+import { GET_ALL_PEDIDOS_STATUS } from './queries'
+
+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.ts

@@ -0,0 +1,80 @@
+import { gql } from '@apollo/client'
+
+export const GET_ALL_PEDIDOS_STATUS = gql`
+  query getAllPedidoUserFinal($id: ID) {
+    getAllPedidoUserFinal(id: $id) {
+      pdpId
+      idStore
+      pCodeRef
+      payId
+      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
+        payId
+        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/useStock/index.ts

@@ -0,0 +1 @@
+export { useStockUpdatedAllSubscription } from './useStockUpdatedAllSubscription'

package/src/hooks/useStock/useStockUpdatedAllSubscription.ts

@@ -0,0 +1,40 @@
+
+import { useSubscription, gql } from '@apollo/client'
+
+const NEW_STORE_ORDER_SUBSCRIPTION = gql`
+ subscription StockUpdatedAll($idStore: String) {
+    StockUpdatedAll(idStore: $idStore) {
+      pId
+      newStock
+      previousStock
+      event
+      meta
+    }
+  } 
+`
+
+interface StockUpdatedAllData {
+    StockUpdatedAll: {
+        pId: string
+        newStock: number
+        previousStock: number
+        event: string
+        meta: any
+    }
+}
+
+export const useStockUpdatedAllSubscription = (
+  idStore: string,
+  onStockUpdated: (data: StockUpdatedAllData['StockUpdatedAll']) => void
+) => {
+  return useSubscription<StockUpdatedAllData>(NEW_STORE_ORDER_SUBSCRIPTION, {
+    variables: { idStore },
+    skip: !idStore,
+    onSubscriptionData: ({ subscriptionData }) => {
+      const data = subscriptionData.data?.StockUpdatedAll
+      if (!data) return
+      onStockUpdated(data)
+    }
+  })
+}
+

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

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

package/src/hooks/useStockMovements/index.ts

@@ -0,0 +1,39 @@
+import { useQuery, gql } from '@apollo/client'
+import { useState, useEffect } from 'react'
+
+import { fillMissingDates } from './helpers'
+
+const GET_STOCK_MOVEMENTS = gql`
+  query {
+    getStockMovementsByDay {
+      date
+      total_in,
+      total_adjustment
+      total_out
+    }
+  }
+`
+
+/**
+ * Custom hook to fetch stock movements data for visualization.
+ * @returns {Object} { data, loading, error }
+ */
+export const useStockMovements = () => {
+  const { data, loading, error } = useQuery(GET_STOCK_MOVEMENTS)
+  const [chartData, setChartData] = useState([])
+
+  useEffect(() => {
+    if (data && data.getStockMovementsByDay) {
+      // Transform data to be compatible with Recharts
+      const formattedData = data.getStockMovementsByDay.map(entry => {return {
+        date: entry.date,
+        TotalIn: entry.total_in ?? 0,
+        TotalOut: entry.total_out ?? 0,
+        TotalAdjustment: entry.total_adjustment ?? 0
+      }})
+      setChartData(formattedData)
+    }
+  }, [data])
+
+  return [fillMissingDates(chartData), { loading, error }]
+}

package/src/hooks/useStore/index.ts

@@ -0,0 +1,83 @@
+import { useApolloClient, useQuery } from '@apollo/client'
+import { useState, useEffect } from 'react'
+
+
+import { errorHandler } from '../../config/client'
+import { useLogout } from '../useLogout'
+
+import { GET_ONE_STORE, GET_ONE_STORE_BY_ID } from './queries' // Reemplaza con la importación correcta de tu consulta
+
+export const useStore = ({
+  isClient = false,
+  idStore = null,
+  callback = () => { }
+} = {}) => {
+  const client = useApolloClient()
+  const [onClickLogout, { loading: load }] = useLogout()
+
+  // Variables para almacenar los datos del store
+  const [store, setStore] = useState({})
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState(null)
+
+  // Intentar leer los datos de la caché
+  const cachedData = client.readQuery({ query: GET_ONE_STORE })
+
+  useEffect(() => {
+    if (cachedData) {
+      const array = store ? Object.keys(store) : []
+      // Comprobar si los datos de la caché ya están establecidos en el estado
+      if ((!store || Array.isArray(array)) && array?.length === 0) {
+        setStore(cachedData.getStore)
+      }
+    }
+    callback(store)
+  }, [cachedData, store])
+
+  if (isClient && Boolean(idStore)) {
+    const {
+      data,
+      refetch,
+      loading: loadingClient,
+      error: errorStoreClient
+    } = useQuery(GET_ONE_STORE_BY_ID, {
+      skip: !isClient,
+      variables: {
+        idStore
+      }
+    })
+
+    const dataOneStoreClient = !loadingClient ? data?.getOneStore : {}
+
+    return [dataOneStoreClient, {
+      refetch,
+      loading: loadingClient,
+      error: errorStoreClient
+    }]
+  } 
+  const { loading: loadingServer } = useQuery(GET_ONE_STORE, {
+    skip: isClient && !idStore,
+    variables: {
+      idStore
+    },
+    fetchPolicy: 'cache-first',
+    onCompleted: (data) => {
+      const { getStore } = data || {}
+      setStore(getStore)
+      setLoading(false)
+    },
+    onError: (err) => {
+      if (err.networkError && err.networkError.result) {
+        const response = errorHandler(err.networkError.result)
+        if (response) {
+          onClickLogout()
+        }
+      }
+      setError(err)
+      setLoading(false)
+    }
+  })
+
+  return [store, { loading: load || loadingServer || loading, error }]
+  
+}

package/src/hooks/useStore/queries.ts

@@ -0,0 +1,163 @@
+import { gql } from '@apollo/client'
+
+export const CREATE_ONE_STORE = gql`
+mutation  newRegisterStore($input: IStore){
+  newRegisterStore(input: $input){
+    success
+    message
+    idStore
+  }
+}
+`
+
+export const GET_ONE_STORE = gql`
+query getStore($id: ID, $idStore: ID) {
+  getStore(id: $id, idStore: $idStore) {
+    cId
+    id
+    deliveryTimeMinutes
+    scheduleOpenAll
+    dId
+    idStore
+    ctId
+    neighborhoodStore
+    Viaprincipal
+    catStore
+    storeOwner
+    storeName
+    ImageName
+    emailStore
+    storePhone
+    socialRaz
+    Image
+    banner
+
+    documentIdentifier
+    uPhoNum
+    storeName
+    ULocation
+    upLat
+    upLon
+    uState
+    siteWeb
+    dailyGoal
+    description
+    createdAt
+    secVia
+    NitStore
+    typeRegiments
+    typeContribute
+    addressStore
+    pais {
+      cId
+      cName
+      cCalCod
+      cState
+      cDatCre
+      cDatMod
+    }
+    city {
+      ctId
+      dId
+      cName
+      cState
+      cDatCre
+      cDatMod
+    }
+    department {
+      dId
+      cId
+      dName
+      dState
+      dDatCre
+      dDatMod
+    }
+    getStoreSchedules {
+      idStore
+      schId
+      id
+      schDay
+      schHoSta
+      schHoEnd
+      schState
+    }
+    cateStore {
+      catStore
+      cName
+      cState
+      createdAt
+      updatedAt
+      csDescription
+    }
+  }
+}
+`
+export const GET_ONE_STORE_BY_ID = gql`
+query getOneStore($StoreName: String, $idStore: ID){
+  getOneStore(idStore: $idStore, StoreName: $StoreName) {
+    idStore
+    cId
+    id
+    dId
+    ctId
+    catStore
+    neighborhoodStore 
+    Viaprincipal
+    storeOwner
+    storeName
+    emailStore
+    storePhone
+    socialRaz
+    Image
+    banner
+    documentIdentifier
+    uPhoNum
+    ULocation
+    upLat
+    upLon
+    uState
+    siteWeb
+    description
+    NitStore
+    typeRegiments
+    typeContribute
+    secVia
+    addressStore
+    createdAt
+    pais{
+      cId
+      cName
+      cCalCod
+      cState
+      cDatCre
+      cDatMod
+    }
+    city {
+      ctId
+      dId
+      cName
+      cState
+      cDatCre
+      cDatMod
+    }
+    department {
+      dId
+      cId
+      dName
+      dState
+      dDatCre
+      dDatMod
+    }
+    cateStore {
+      catStore
+      idUser
+      cName
+      cState
+      cDatCre
+      cDatMod
+      csDescription
+      
+    }
+  }
+}
+`

package/src/hooks/useStoreCalendar/index.ts

@@ -0,0 +1,5 @@
+export const useStoreCalendar = () => {
+  return {
+    true: true
+  }
+}

package/src/hooks/useStoreContacts/index.ts

@@ -0,0 +1,53 @@
+import { useQuery, useMutation, useLazyQuery } from '@apollo/client'
+import { useState } from 'react'
+
+import {
+  GET_ALL_CONTACTS,
+  EDIT_ONE_CONTACT,
+  CREATE_CONTACTS,
+  GET_ONE_CONTACT
+} from './queries'
+
+interface UseStoreContactsParams {
+  sendNotification?: (message: string, type?: 'error' | 'success') => void
+  max?: number
+  search?: string
+}
+export const useGetStoreContacts = ({
+  sendNotification = () => { },
+  max,
+  search = ''
+}: UseStoreContactsParams = {}) => {
+  const [clientes, setClientes] = useState<{ getAllContacts?: any[] } | undefined>(undefined)
+  const { loading, error, fetchMore, called } = useQuery(GET_ALL_CONTACTS, {
+    variables: {
+      max,
+      search
+    },
+    onCompleted: (data) => {
+      setClientes(data)
+    }
+  })
+  return [clientes?.getAllContacts ?? [], { loading: called ? false : loading, error, fetchMore }]
+}
+
+export const useDeleteUseStoreContacts = ({ sendNotification = () => { } } = {}) => {
+  const [getOneContacts, { data, error, loading }] = useLazyQuery(GET_ONE_CONTACT)
+  return [getOneContacts, data?.getOneContacts ?? {}, { loading, error }]
+}
+
+export const useGetOneUseStoreContacts = ({ sendNotification = () => { } } = {}) => {
+  const [getOneContacts, { data, error, loading }] = useLazyQuery(GET_ONE_CONTACT)
+  return [getOneContacts, { data: data?.getOneContacts, loading, error }]
+}
+
+export const useEditOneUseStoreContacts = ({ sendNotification = () => { } } = {}) => {
+  const [editOneContacts, { data, error, loading }] = useMutation(EDIT_ONE_CONTACT)
+  return [editOneContacts, { data: data?.editOneContacts, loading, error }]
+}
+
+export const useCreateContacts = ({ sendNotification = () => { } } = {}) => {
+  const [createUseStoreContacts, { loading, error }] = useMutation(CREATE_CONTACTS)
+
+  return [createUseStoreContacts, { loading, error }]
+}

package/src/hooks/useStoreContacts/queries.ts

@@ -0,0 +1,48 @@
+import { gql } from '@apollo/client'
+
+export const CREATE_CONTACTS = gql`
+mutation createContacts ($input: IContacts) {
+  createContacts(input: $input) {
+    success
+    message
+  }
+}
+`
+export const GET_ALL_CONTACTS = gql`
+query getAllContacts($idStore: ID, $cId: ID, $dId: ID, $ctId: ID, $search: String, $min: Int, $pState: Int,  $max: Int) {
+  getAllContacts(idStore: $idStore, cId: $cId, dId: $dId, ctId: $ctId, search: $search, min: $min, pState: $pState,  max: $max) {
+    contactId
+    cntState
+    cntComments
+    cntNumberPhone
+    cntName
+    createAt
+    updateAt
+  }
+}
+`
+
+export const GET_ONE_CONTACT = gql`
+query getOneContacts($contactId: String) {
+  getOneContacts(contactId: $contactId) {
+    contactId
+    id
+    idStore
+    cntName
+    cntComments
+    cntNumberPhone
+    cntState
+    createAt
+    updateAt
+  }
+}
+`
+
+export const EDIT_ONE_CONTACT = gql`
+mutation editOneContacts($input: IContacts) {
+  editOneContacts(input: $input) {
+    success
+    message
+  }
+}
+`

package/src/hooks/useStoreTable/index.ts

@@ -0,0 +1,2 @@
+export * from './useStoreTableCreate'
+export * from './useStoreTables'

package/src/hooks/useStoreTable/queries.ts

@@ -0,0 +1,47 @@
+import { gql } from '@apollo/client'
+
+/**
+ * GraphQL Mutation for creating a store table
+ */
+export const CREATE_TABLE_MUTATION = gql`
+  mutation storeTableCreate($tableName: String!, $seats: Int, $section: String, $tableState: Int) {
+    storeTableCreate(tableName: $tableName, seats: $seats, section: $section, tableState: $tableState) {
+      success
+      message
+      errors {
+        message
+        path
+        type
+        context {
+          limit
+          value
+          label
+          key
+        }
+      }
+      data {
+        tableId
+        tableName
+        seats
+        section
+        tableState
+        createdAt
+        updatedAt
+      }
+    }
+  }
+`
+
+export const STORE_TABLES_QUERY = gql`
+  query {
+    storeTables {
+      tableId
+      tableName
+      seats
+      section
+      tableState
+      createdAt
+      updatedAt
+    }
+  }
+`

package/src/hooks/useStoreTable/useStoreTableCreate.ts

@@ -0,0 +1,77 @@
+import { useMutation } from '@apollo/client'
+import { useState } from 'react'
+
+import { CREATE_TABLE_MUTATION } from './queries'
+
+/**
+ * Custom hook to handle table creation with validation and mutation logic
+ * @param {string} tableName Name of the table
+ * @param {number} seats Number of seats at the table
+ * @param {string} section Section where the table is located
+ * @param {number} tableState Current state of the table (e.g., Active, Occupied)
+ * @returns {Object} The state of the mutation including success, message, errors, and data
+ */
+export const useStoreTableCreate = ({
+  sendNotification = () => {}
+} = {}) => {
+  const [loading, setLoading] = useState(false)
+  const [createTableMutation] = useMutation(CREATE_TABLE_MUTATION)
+  /**
+   * Function to create a table with validation and mutation
+   * @param {string} tableName Table name
+   * @param {number} seats Number of seats
+   * @param {string} section Table section
+   * @param {number} tableState Table state (e.g., 0 = Unavailable, 1 = Active, 2 = Occupied)
+   */
+  const storeTableCreate = async (tableName, seats, section, tableState) => {
+    setLoading(true) // Start loading
+    try {
+      // Call the mutation to create the table
+      const result = await createTableMutation({
+        variables: {
+          tableName,
+          seats,
+          section,
+          tableState
+        },
+        update (cache, { data: { storeTableCreate } }) {
+          if (storeTableCreate.success) {
+            // Actualizar la lista de mesas en la caché
+            cache.modify({
+              fields: {
+                storeTables (existingTables = []) {
+                  const newTableRef = {
+                    tableId: null,
+                    tableName,
+                    seats,
+                    section,
+                    tableState: 1
+                  }
+                  return [...existingTables, newTableRef]
+                }
+              }
+            })
+          }
+        }
+      })
+
+      sendNotification({
+        backgroundColor: result.data.storeTableCreate.success ? 'success' : 'error',
+        description: result.data.storeTableCreate.message || '',
+        title: result.data.storeTableCreate.success ? 'Success' : 'Error'
+      })
+      return result
+    } catch (error) {
+      sendNotification({
+        backgroundColor: 'error',
+        description: error.message || 'Error occurred while creating the table.',
+        title: 'Creation Failed'
+      })
+      return { success: false, message: error.message }
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  return [storeTableCreate, { loading }]
+}

package/src/hooks/useStoreTable/useStoreTables.ts

@@ -0,0 +1,15 @@
+import { useQuery } from '@apollo/client'
+
+import { STORE_TABLES_QUERY } from './queries' // Ajusta la ruta a tu archivo de queries
+
+/**
+ * Custom hook to fetch store tables data
+ * @param {Object} args - Arguments for fetching store tables, e.g., info field.
+ * @param {Object} ctx - Context that provides restaurant-related information.
+ * @returns {Object} - Object containing tables data, loading state, and error.
+ */
+export const useStoreTables = () => {
+  const { data, loading, error } = useQuery(STORE_TABLES_QUERY)
+
+  return [data, { loading, error }]
+}