npm-pkg-hook 1.12.7 → 1.12.8

package/src/hooks/useProductsFood/useEditProduct.ts

@@ -0,0 +1,49 @@
+import { useMutation } from '@apollo/client'
+
+import { EDIT_PRODUCT } from './queriesStore'
+
+export const useEditProduct = ({
+  sendNotification = () => {
+    return null
+  }
+} = {}) => {
+  const [editProductFoods, { loading, error }] = useMutation(EDIT_PRODUCT, {
+    onCompleted: (data) => {
+      const { editProductFoods } = data
+      const {
+        success,
+        message,
+        errors
+      } = editProductFoods || {
+        success: false,
+        message: '',
+        errors: []
+      }
+      if (errors && errors.length > 0) {
+        for (const error of errors) {
+          sendNotification({
+            title: 'Error',
+            description: `${error.message}`,
+            backgroundColor: 'error'
+          })
+        }
+      }
+      if (success) {
+        sendNotification({
+          title: 'Error',
+          description: `${message}`,
+          backgroundColor: 'error'
+        })
+      }
+    },
+    onError: (error) => {
+      sendNotification({
+        title: 'Error',
+        description: error.message,
+        backgroundColor: 'error'
+      })
+    }
+  })
+
+  return [editProductFoods, { loading, error }]
+}

package/src/hooks/useProductsFood/usetagsProducts.ts

@@ -0,0 +1,101 @@
+import { useMutation } from '@apollo/client'
+import { useState } from 'react'
+
+import { useDeleteOneTag, useGetAllTags } from '../useTagProducts'
+
+import { REGISTER_TAGS_PRODUCT } from './queriesStore'
+
+
+export const useTagsProducts = ({
+  sendNotification = () => { }
+} = {}) => {
+  const [registerTag] = useMutation(REGISTER_TAGS_PRODUCT)
+  const [handleDeleteTag, { loading }] = useDeleteOneTag()
+  const { tags: listTags } = useGetAllTags()
+  const [newTags, setNewTags] = useState([])
+
+  const [tags, setTags] = useState({
+    id: '',
+    tag: ''
+  })
+
+  const handleAddTag = (id, tag) => {
+    if (tags.id === id) {
+      return setTags({
+        id: '',
+        tag: ''
+      })
+    }
+    return setTags({
+      id,
+      tag
+    })
+  }
+
+  const handleRemoveTag = async (tag) => {
+    try {
+      if (loading) return
+      const { id: tgId, tag: nameTag } = tag ?? {
+        tgId: null,
+        nameTag: null
+      }
+      const response = await handleDeleteTag({ tgId, nameTag })
+      const {
+        success = false,
+        message = '',
+        data
+      } = response ?? {}
+
+      const name = data?.nameTag ?? ''
+      return sendNotification({
+        title: name ?? 'error',
+        description: message,
+        backgroundColor: success ? 'success' : 'error'
+      })
+    } catch (e) {
+      sendNotification({
+        title: 'Error',
+        description: 'error',
+        backgroundColor: 'error'
+      })
+    }
+  }
+
+  const handleRegister = tag => {
+    const {
+      pId,
+      idUser,
+      idStore,
+      nameTag
+    } = tag || {}
+
+    registerTag({
+      variables: {
+        input: {
+          pId,
+          idUser,
+          nameTag,
+          idStore
+        }
+      }
+    }).catch(err => { return console.log({ message: `${err}`, duration: 7000 }) })
+  }
+  const data = listTags.map((tag) => {
+    return {
+      id: tag?.tgId ?? '',
+      tag: String(tag?.nameTag ?? '')
+    }
+  })
+
+  return {
+    tags,
+    error: false,
+    data,
+    loading: false,
+    newTags: newTags ?? [],
+    setNewTags,
+    handleRegister,
+    handleRemoveTag,
+    handleAddTag
+  }
+}

package/src/hooks/useProviders/index.ts

@@ -0,0 +1,3 @@
+export * from './useProvidersCreateStore'
+export * from './useProvidersDataStore'
+export * from './queries'

package/src/hooks/useProviders/queries.ts

@@ -0,0 +1,31 @@
+import { gql } from '@apollo/client'
+
+export const CREATE_PROVIDERS = gql`
+mutation registerProviders($input: IProviders) {
+  registerProviders(input: $input) {
+    success
+    message
+  }
+}
+`
+export const GET_ALL_PROVIDERS = gql`
+query getAllProviders($idStore: ID,$search: String, $min: Int, $max: Int $fromDate: DateTime, $toDate: DateTime ) {
+  getAllProviders(idStore: $idStore, search: $search, min: $min, max: $max, toDate: $toDate, fromDate: $fromDate) {
+    idProvider
+    idStore
+    prImage
+    prPathImage
+    PrNit
+    prName
+    PrNumberPhone
+    PrNumberIdentity
+    PrAdres
+    PrMail
+    TotalBysPr
+    TotalDeuda
+    prState
+    DatCre
+    DatMod
+  }
+}
+`

package/src/hooks/useProviders/useProvidersCreateStore/index.ts

@@ -0,0 +1,13 @@
+import { useMutation } from '@apollo/client'
+
+import { CREATE_PROVIDERS } from '../queries'
+
+export const useProvidersCreateStore = ({ setAlertBox = () => { } } = {}) => {
+  const [registerProviders, { loading, error }] = useMutation(CREATE_PROVIDERS, {
+    onCompleted: (data) => {
+      setAlertBox({ message: `${data.registerProviders.message}` })
+    }
+  })
+
+  return [registerProviders, { loading, error }]
+}

package/src/hooks/useProviders/useProvidersDataStore/index.ts

@@ -0,0 +1,25 @@
+import { useQuery } from '@apollo/client'
+
+import { GET_ALL_PROVIDERS } from '../queries'
+
+export const useProvidersStore = () => {
+  const {
+    data,
+    fetchMore,
+    loading,
+    error,
+    called
+  } = useQuery(GET_ALL_PROVIDERS, {
+    fetchPolicy: 'cache-and-network',
+    notifyOnNetworkStatusChange: true,
+    nextFetchPolicy: 'cache-first',
+    refetchWritePolicy: 'merge'
+  })
+  const providerData = data?.getAllProviders || []
+  return [providerData, {
+    fetchMore,
+    called,
+    error,
+    loading
+  }]
+}

package/src/hooks/useProvidersStore/index.ts

@@ -0,0 +1,25 @@
+import { useQuery } from '@apollo/client'
+
+import { GET_ALL_PROVIDERS } from './queries'
+
+export const useProvidersStore = () => {
+  const {
+    data,
+    fetchMore,
+    loading,
+    error,
+    called
+  } = useQuery(GET_ALL_PROVIDERS, {
+    fetchPolicy: 'cache-and-network',
+    notifyOnNetworkStatusChange: true,
+    nextFetchPolicy: 'cache-first',
+    refetchWritePolicy: 'merge'
+  })
+  const providerData = data?.getAllProviders || []
+  return [providerData, {
+    fetchMore,
+    called,
+    error,
+    loading
+  }]
+}

package/src/hooks/useProvidersStore/queries.ts

@@ -0,0 +1,31 @@
+import { gql } from '@apollo/client'
+
+export const CREATE_PROVIDERS = gql`
+mutation registerProviders($input: IProviders) {
+  registerProviders(input: $input) {
+    success
+    message
+  }
+}
+`
+export const GET_ALL_PROVIDERS = gql`
+query getAllProviders($idStore: ID,$search: String, $min: Int, $max: Int $fromDate: DateTime, $toDate: DateTime ) {
+  getAllProviders(idStore: $idStore, search: $search, min: $min, max: $max, toDate: $toDate, fromDate: $fromDate) {
+    idProvider
+    idStore
+    prImage
+    prPathImage
+    PrNit
+    prName
+    PrNumberPhone
+    PrNumberIdentity
+    PrAdres
+    PrMail
+    TotalBysPr
+    TotalDeuda
+    prState
+    DatCre
+    DatMod
+  }
+}
+`

package/src/hooks/usePushNotificationOrder/index.ts

@@ -0,0 +1,52 @@
+import { useMutation, gql } from '@apollo/client'
+
+// Define el mutation GraphQL
+const PUSH_NOTIFICATION_ORDER = gql`
+  mutation PushNotificationOrder($pCodeRef: String!, $idStore: ID!) {
+    pushNotificationOrder(pCodeRef: $pCodeRef, idStore: $idStore) {
+      pdpId
+      id
+      idStore
+      pId
+      ppState
+      pCodeRef
+      pPDate
+      pSState
+      pPStateP
+      payId
+      pPRecoger
+      totalProductsPrice
+      unidProducts
+      pDatCre
+      pDatMod
+    }
+  }
+`
+
+// Definir el hook personalizado
+export const usePushNotificationOrder = ({ client }) => {
+  // Usar el hook useMutation para ejecutar el mutation
+  const [pushNotificationOrderMutation] = useMutation(PUSH_NOTIFICATION_ORDER, {
+    context: { clientName: client }
+  })
+
+  // Función para ejecutar el mutation
+  const pushNotificationOrder = async (pCodeRef, idStore) => {
+    try {
+      // Ejecutar el mutation con los parámetros proporcionados
+      const { data } = await pushNotificationOrderMutation({
+        variables: { pCodeRef, idStore }
+      })
+
+      // Devolver los datos de la orden recibidos del servidor
+      return data.pushNotificationOrder
+    } catch (error) {
+      // Manejar cualquier error que ocurra durante la ejecución del mutation
+      console.error('Error al ejecutar el mutation pushNotificationOrder:', error)
+      throw new Error('Error al publicar la nueva orden de tienda. Por favor, vuelve a intentarlo.')
+    }
+  }
+
+  // Devolver la función pushNotificationOrder para ser utilizada por el componente
+  return pushNotificationOrder
+}

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

@@ -0,0 +1,123 @@
+/* eslint-disable consistent-return */
+const pushServerPublicKey = 'BIN2Jc5Vmkmy-S3AUrcMlpKxJpLeVRAfu9WBqUbJ70SJOCWGCGXKY-Xzyh7HDr6KbRDGYHjqZ06OcS3BjD7uAm8'
+
+/**
+ * checks if Push notification and service workers are supported by your browser
+ */
+function isPushNotificationSupported () {
+  if (typeof window !== 'undefined' && window.Notification && window.ServiceWorker) {
+    return 'serviceWorker' in navigator && 'PushManager' in window
+  }
+}
+
+/**
+ * asks user consent to receive push notifications and returns the response of the user, one of granted, default, denied
+ */
+async function askUserPermission () {
+  return await Notification.requestPermission()
+}
+/**
+ * shows a notification
+ */
+function sendNotification () {
+  const img = '/images/jason-leung-HM6TMmevbZQ-unsplash.jpg'
+  const text = 'Take a look at this brand new t-shirt!'
+  const title = 'New Product Available'
+  const options = {
+    body: text,
+    icon: '/images/jason-leung-HM6TMmevbZQ-unsplash.jpg',
+    vibrate: [200, 100, 200],
+    tag: 'new-product',
+    image: img,
+    badge: 'https://spyna.it/icons/android-icon-192x192.png',
+    actions: [{ action: 'Detail', title: 'View', icon: 'https://via.placeholder.com/128/ff0000' }]
+  }
+  navigator.serviceWorker.ready.then(function (serviceWorker) {
+    serviceWorker.showNotification(title, options)
+  })
+}
+
+/**
+ *
+ */
+function registerServiceWorker () {
+  return navigator.serviceWorker.register('/sw.js')
+}
+
+/**
+ *
+ * using the registered service worker creates a push notification subscription and returns it
+ *
+ */
+async function createNotificationSubscription () {
+  // wait for service worker installation to be ready
+  const serviceWorker = await navigator.serviceWorker.ready
+  // subscribe and return the subscription
+  return await serviceWorker.pushManager.subscribe({
+    userVisibleOnly: true,
+    applicationServerKey: pushServerPublicKey
+  })
+}
+
+/**
+ * returns the subscription if present or nothing
+ */
+function getUserSubscription () {
+  // wait for service worker installation to be ready, and then
+  return navigator.serviceWorker.ready
+    .then(function (serviceWorker) {
+      return serviceWorker.pushManager.getSubscription()
+    })
+    .then(function (pushSubscription) {
+      return pushSubscription
+    })
+}
+
+const host = process.env.NODE_ENV === 'production' ? 'http://localhost:4000' : 'http://localhost:4000'
+
+/**
+ *
+ * @param path
+ * @param body
+ */
+function post (path, body) {
+  return fetch(`${host}${path}`, {
+    body: JSON.stringify(body),
+    method: 'POST',
+    mode: 'cors'
+  })
+    .then(function (response) {
+      return response.json()
+    })
+    .then(function (data) {
+      return data
+    })
+}
+
+/**
+ *
+ * @param path
+ */
+function get (path) {
+  return fetch(`${host}${path}`, {
+    method: 'GET',
+    mode: 'cors'
+  })
+    .then(function (response) {
+      return response.json()
+    })
+    .then(function (data) {
+      return data
+    })
+}
+
+export {
+  isPushNotificationSupported,
+  askUserPermission,
+  post,
+  get,
+  registerServiceWorker,
+  sendNotification,
+  createNotificationSubscription,
+  getUserSubscription
+}

package/src/hooks/usePushNotifications/index.ts

@@ -0,0 +1,150 @@
+/* eslint-disable no-console */
+import { useState, useEffect } from 'react'
+
+import {
+  isPushNotificationSupported,
+  post,
+  get,
+  askUserPermission,
+  registerServiceWorker,
+  createNotificationSubscription,
+  getUserSubscription
+} from './helpers'
+// import all the function created to manage the push notifications
+
+const pushNotificationSupported = isPushNotificationSupported()
+// first thing to do: check if the push notifications are supported by the browser
+
+export const usePushNotifications = () => {
+  const [userConsent, setSuserConsent] = useState()
+  useEffect(() => {
+    if (typeof Notification !== 'undefined') {
+      setSuserConsent(Notification.permission)
+    }
+  }, [])
+
+  // to manage the user consent: Notification.permission is a JavaScript native function that return the current state of the permission
+  // We initialize the userConsent with that value
+  const [userSubscription, setUserSubscription] = useState(null)
+  // to manage the use push notification subscription
+  const [pushServerSubscriptionId, setPushServerSubscriptionId] = useState()
+  // to manage the push server subscription
+  const [error, setError] = useState(null)
+  // to manage errors
+  const [loading, setLoading] = useState(true)
+  // to manage async actions
+
+  useEffect(() => {
+    if (pushNotificationSupported) {
+      setLoading(true)
+      setError(false)
+      registerServiceWorker().then(() => {
+        setLoading(false)
+      })
+    }
+  }, [])
+  // if the push notifications are supported, registers the service worker
+  // this effect runs only the first render
+
+  useEffect(() => {
+    setLoading(true)
+    setError(false)
+    const getExixtingSubscription = async () => {
+      const existingSubscription = await getUserSubscription()
+      setUserSubscription(existingSubscription)
+      setLoading(false)
+    }
+    getExixtingSubscription()
+  }, [])
+  // Retrieve if there is any push notification subscription for the registered service worker
+  // this use effect runs only in the first render
+
+  /**
+   * define a click handler that asks the user permission,
+   * it uses the setSuserConsent state, to set the consent of the user
+   * If the user denies the consent, an error is created with the setError hook
+   */
+  const onClickAskUserPermission = () => {
+    setLoading(true)
+    setError(false)
+    askUserPermission().then(consent => {
+      setSuserConsent(consent)
+      if (consent !== 'granted') {
+        setError({
+          name: 'consentimiento denegado',
+          message: 'Negaste el consentimiento para recibir notificaciones',
+          code: 0
+        })
+      }
+      setLoading(false)
+    })
+  }
+  //
+
+  /**
+   * define a click handler that creates a push notification subscription.
+   * Once the subscription is created, it uses the setUserSubscription hook
+   */
+  const onClickSusbribeToPushNotification = () => {
+    setLoading(true)
+    setError(false)
+    createNotificationSubscription()
+      .then(function (subscrition) {
+        setUserSubscription(subscrition)
+        setLoading(false)
+      })
+      .catch(err => {
+        console.error("Couldn't create the notification subscription", err, 'name:', err.name, 'message:', err.message, 'code:', err.code)
+        setError(err)
+        setLoading(false)
+      })
+  }
+
+  /**
+   * define a click handler that sends the push susbcribtion to the push server.
+   * Once the subscription ics created on the server, it saves the id using the hook setPushServerSubscriptionId
+   */
+  const onClickSendSubscriptionToPushServer = () => {
+    setLoading(true)
+    setError(false)
+    post('/subscription2', userSubscription)
+      .then(function (response) {
+        setPushServerSubscriptionId(response.id)
+        setLoading(false)
+      })
+      .catch(err => {
+        setLoading(false)
+        setError(err)
+      })
+  }
+
+  /**
+   * define a click handler that request the push server to send a notification, passing the id of the saved subscription
+   */
+  const onClickSendNotification = async () => {
+    setLoading(true)
+    setError(false)
+    console.log(pushServerSubscriptionId)
+    await get(`/subscription/${pushServerSubscriptionId}`).catch(err => {
+      setLoading(false)
+      setError(err)
+    })
+    setLoading(false)
+  }
+
+  /**
+   * returns all the stuff needed by a Component
+   */
+  return {
+    onClickAskUserPermission,
+    onClickSusbribeToPushNotification,
+    onClickSendSubscriptionToPushServer,
+    pushServerSubscriptionId,
+    onClickSendNotification,
+    userConsent,
+    pushNotificationSupported,
+    userSubscription,
+    error,
+    loading
+  }
+}

package/src/hooks/useQueryLocationsMap/index.ts

@@ -0,0 +1,20 @@
+import { useLazyQuery } from '@apollo/client'
+
+import { GET_ONE_COUNTRY, GET_ONE_DEPARTMENT, GET_ONE_CITY } from './queries'
+
+const useGetOneCountry = () => {
+  const [getOneCountry, { data: dataCountry }] = useLazyQuery(GET_ONE_COUNTRY)
+  return { getOneCountry, dataCountry }
+}
+
+const useGetOneDepartment = () => {
+  const [getOneDepartment, { data: dataDepartment }] = useLazyQuery(GET_ONE_DEPARTMENT)
+  return { getOneDepartment, dataDepartment }
+}
+
+const useGetOneCity = () => {
+  const [getOneCities, { data: dataGetOneCity }] = useLazyQuery(GET_ONE_CITY)
+  return { getOneCities, dataGetOneCity }
+}
+
+export { useGetOneCountry, useGetOneDepartment, useGetOneCity }

package/src/hooks/useQueryLocationsMap/queries.ts

@@ -0,0 +1,40 @@
+import { gql } from '@apollo/client'
+
+export const GET_ONE_COUNTRY = gql`
+query getOneCountry($cId: ID){
+  getOneCountry(cId: $cId) {
+    cId
+    cName
+    cName
+    cDatCre
+    cCalCod
+    cState
+    cDatMod
+
+  }
+}
+`
+export const GET_ONE_DEPARTMENT = gql`
+query getOneDepartment($dId: ID){
+    getOneDepartment(dId: $dId) {
+    dId
+    cId
+    dName
+    dState
+    dDatCre
+    dDatMod
+  }
+}
+`
+export const GET_ONE_CITY = gql`
+query getOneCities($ctId: ID){
+    getOneCities(ctId: $ctId) {
+        ctId
+        dId
+        cName
+        cState
+        cDatCre
+        cDatMod
+  }
+}
+`