npm-pkg-hook 1.12.7 → 1.12.8

package/src/hooks/useCatWithProduct/types/index.ts

@@ -0,0 +1,104 @@
+export interface ICatWithProduct {
+  max?: number
+  min?: number
+  search?: string | null
+  productName?: string | null
+  searchFilter?: {
+    gender?: string[]
+    desc?: string | null
+    speciality?: string[]
+  }
+  callback?: Function  
+}
+
+
+// =====================
+// Query Variables
+// =====================
+
+export interface GetCatProductsWithProductVariables {
+  search?: string
+  productName?: string
+  min?: number
+  max?: number
+  gender?: string[]
+  desc?: string[]
+  categories?: string[]
+}
+
+// =====================
+// Response Types
+// =====================
+
+export interface GetCatProductsWithProductResponse {
+  getCatProductsWithProduct: {
+    totalCount: number
+    catProductsWithProduct: CatProductWithProduct[]
+  }
+}
+
+// =====================
+// Main Entities
+// =====================
+
+export interface CatProductWithProduct {
+  carProId: string
+  pState: number
+  ProImage: string | null
+  idStore: string
+  pName: string
+  totalCount: number
+  checked?: boolean
+  ProDescription?: string | null
+  createdAt: string
+  updatedAt: string
+  productFoodsAll: ProductFood[]
+}
+
+export interface ProductFood {
+  pId: string
+  stock: number
+  manageStock: boolean
+  sizeId?: string | null
+  colorId?: string | null
+  carProId: string
+  cId?: string | null
+  dId?: string | null
+  ctId?: string | null
+  idStore: string
+  caId?: string | null
+  fId?: string | null
+  pName: string
+  ProPrice: number
+  ProDescuento?: number | null
+  ProUniDisponibles?: number | null
+  ProDescription?: string | null
+  ProProtegido?: boolean | null
+  ProAssurance?: boolean | null
+  ProImage?: string | null
+  ProStar?: number | null
+  ProWidth?: number | null
+  ProHeight?: number | null
+  ProLength?: number | null
+  ProWeight?: number | null
+  ProQuantity?: number | null
+  ProOutstanding?: boolean | null
+  ProDelivery?: boolean | null
+  ProVoltaje?: string | null
+  pState: number
+  sTateLogistic?: number | null
+  createdAt: string
+  updatedAt: string
+  product_availables: ProductAvailable[]
+}
+
+export interface ProductAvailable {
+  availableProductId: string
+  pId: string
+  idStore: string
+  dayAvailable: string
+  startDate: string
+  endDate: string
+  createdAt: string
+  updatedAt: string
+}

package/src/hooks/useCatWithProductClient/index.ts

@@ -0,0 +1,57 @@
+import { useQuery } from '@apollo/client'
+import { useMemo } from 'react'
+
+import { GET_ALL_CATEGORIES_WITH_PRODUCT_CLIENTS } from './queries'
+
+/**
+ * Custom hook to fetch categories with product data.
+ *
+ * @param {string} idStore - The ID of the store.
+ * @returns {object} - The hook result containing filtered data, loading state, and fetch function.
+ */
+export const useCatWithProductClient = (idStore) => {
+  const { data, loading, error, fetchMore } = useQuery(GET_ALL_CATEGORIES_WITH_PRODUCT_CLIENTS, {
+    fetchPolicy: 'cache-and-network',
+    variables: {
+      max: 100,
+      idStore,
+      search: '',
+      gender: [],
+      desc: [],
+      categories: []
+    }
+  })
+
+  const fetchCategories = () => {
+    fetchMore({
+      variables: {
+        max: 100,
+        idStore,
+        search: '',
+        gender: [],
+        desc: [],
+        categories: []
+      },
+      updateQuery: (prev, { fetchMoreResult }) => {
+        if (!fetchMoreResult) return prev
+        return {
+          ...prev,
+          getCatProductsWithProductClient: fetchMoreResult.getCatProductsWithProductClient
+        }
+      }
+    })
+  }
+
+  // Utiliza useMemo para memorizar el resultado filtrado
+  const filteredData = useMemo(() => {
+    return data?.getCatProductsWithProductClient?.filter(
+      (category) => {return category?.productFoodsAll?.length > 0}
+    ) || []
+  }, [data])
+
+  return [filteredData, {
+    loading,
+    error,
+    fetchCategories
+  }]
+}

package/src/hooks/useCatWithProductClient/queries.ts

@@ -0,0 +1,56 @@
+import { gql } from '@apollo/client'
+
+export const GET_ALL_CATEGORIES_WITH_PRODUCT_CLIENTS = gql`
+query getCatProductsWithProductClient($search: String, $min: Int, $max: Int, $gender: [String], $desc: [String], $categories: [ID], $carProId: ID $idStore: ID ) {
+  getCatProductsWithProductClient(search: $search, min: $min, max: $max, gender: $gender, desc: $desc, categories: $categories, carProId: $carProId idStore: $idStore) {
+    carProId
+    pState
+    pState
+    ProImage
+    idStore
+    pName
+    ProDescription
+    ProImage
+    pState
+    pDatCre
+    pDatMod
+    productFoodsAll {
+         pId
+        sizeId
+        stock
+        colorId
+        carProId
+        cId
+        dId
+        ValueDelivery
+        ctId
+        idStore
+        caId
+        fId
+        pName
+        ProPrice
+        ProDescuento
+        ProUniDisponibles
+        ProDescription
+        ProProtegido
+        ProAssurance
+        ProImage
+        ProStar
+        ProWidth
+        ProHeight
+        ProLength
+        ProWeight
+        ProQuantity
+        ProOutstanding
+        ProDelivery
+        ProVoltaje
+        pState
+        sTateLogistic
+        pDatCre
+        pDatMod
+      
+    }
+    
+  }
+}
+`

package/src/hooks/useCategoriesProduct/index.ts

@@ -0,0 +1,14 @@
+import { useQuery } from '@apollo/client'
+
+import { GET_ULTIMATE_CATEGORY_PRODUCTS } from './queries'
+
+export const useCategoriesProduct = () => {
+  const {
+    data,
+    loading,
+    error,
+    networkStatus
+  } = useQuery(GET_ULTIMATE_CATEGORY_PRODUCTS)
+
+  return [data?.catProductsAll, { loading, error, networkStatus }]
+}

package/src/hooks/useCategoriesProduct/queries.ts

@@ -0,0 +1,16 @@
+import { gql } from '@apollo/client'
+
+export const GET_ULTIMATE_CATEGORY_PRODUCTS = gql`
+query catProductsAll($search: String, $min: Int, $max: Int, $gender: [String], $desc: [String], $categories: [ID], ) {
+  catProductsAll(search: $search, min: $min, max: $max, gender: $gender, desc: $desc, categories: $categories,) {
+    carProId
+    idStore
+    pName
+    ProDescription
+    ProImage
+    pState
+    createdAt
+    updatedAt
+  }
+}
+`

package/src/hooks/useCategoryInStore/index.ts

@@ -0,0 +1,167 @@
+import { useMutation, useQuery, ApolloError } from '@apollo/client'
+import { useState } from 'react'
+
+import {
+  DELETE_ONE_CAT_PRODUCTS,
+  GET_ULTIMATE_CATEGORY_PRODUCTS,
+  UPDATE_CAT_IN_PRODUCT
+} from '../useProductsFood/queriesStore'
+
+import { GET_ONE_STORE_IN_CATEGORY } from './queries'
+
+/**
+ * Generic alert box handler
+ */
+interface AlertBoxPayload {
+  title?: string
+  message: string
+  color: 'error' | 'success' | 'warning' | 'info'
+}
+
+type SetAlertBox = (payload: AlertBoxPayload) => void
+
+/**
+ * Category entity
+ */
+interface Category {
+  idPc: string
+  pState: string
+  [key: string]: unknown
+}
+
+/**
+ * Hook params
+ */
+interface UseCategoryInStoreParams {
+  catStoreId?: string
+  setAlertBox?: SetAlertBox
+}
+
+/**
+ * Hook return shape
+ */
+interface UseCategoryInStoreResult {
+  categories: Category[]
+  data: Category[]
+  loading: boolean
+  error?: ApolloError
+  handlerDeleteCategoryInStore: (category?: Category) => Promise<unknown> | void
+  handleUpdateCatInProduct: (params: { data?: Array<{ pId: string }> }) => Promise<void>
+}
+
+/**
+ * Custom hook to manage categories in store
+ * @param root0
+ * @param root0.catStoreId
+ * @param root0.setAlertBox
+ */
+export const useCategoryInStore = ({
+  catStoreId,
+  setAlertBox = () => {}
+}: UseCategoryInStoreParams = {}): UseCategoryInStoreResult => {
+  const [categories, setOneCategoryInStore] = useState<Category[]>([])
+
+  const [deleteCatOfProducts] = useMutation(DELETE_ONE_CAT_PRODUCTS, {
+    onError: (e: ApolloError) => {
+      setAlertBox({
+        title: '',
+        message: e.graphQLErrors?.[0]?.message || 'Unexpected error',
+        color: 'error'
+      })
+    },
+    update: (cache) => {
+      cache.modify({
+        fields: {
+          catProductsAll (dataOld = []) {
+            return cache.writeQuery({
+              query: GET_ULTIMATE_CATEGORY_PRODUCTS,
+              data: dataOld
+            })
+          }
+        }
+      })
+    }
+  })
+
+  const [updatedCatWithProducts] = useMutation(UPDATE_CAT_IN_PRODUCT, {
+    onError: (e: ApolloError) => {
+      console.error({
+        message: e.graphQLErrors?.[0]?.message || 'Unexpected error',
+        color: 'error'
+      })
+    },
+    update: (cache) => {
+      cache.modify({
+        fields: {
+          catProductsAll (dataOld = []) {
+            return cache.writeQuery({
+              query: GET_ULTIMATE_CATEGORY_PRODUCTS,
+              data: dataOld
+            })
+          }
+        }
+      })
+    }
+  })
+
+  const { data } = useQuery(GET_ULTIMATE_CATEGORY_PRODUCTS)
+
+  const { loading, error } = useQuery(GET_ONE_STORE_IN_CATEGORY, {
+    variables: {
+      catStore: catStoreId
+    },
+    skip: !catStoreId,
+    onError: () => {
+      console.warn({ message: 'Failed loading category store', duration: 5000 })
+    },
+    onCompleted: (response) => {
+      if (response?.getOneCatStore) {
+        setOneCategoryInStore(response.getOneCatStore)
+      }
+    }
+  })
+
+  /**
+   * Delete category from products
+   * @param category
+   */
+  const handlerDeleteCategoryInStore = (category?: Category) => {
+    const { pState, idPc } = category || {}
+    if (!idPc || !pState) return
+
+    return deleteCatOfProducts({
+      variables: { idPc, pState }
+    })
+  }
+
+  /**
+   * Update category in products
+   * @param root0
+   * @param root0.data
+   */
+  const handleUpdateCatInProduct = async ({
+    data
+  }: {
+    data?: Array<{ pId: string }>
+  }): Promise<void> => {
+    if (!data?.length) return
+
+    await updatedCatWithProducts({
+      variables: {
+        input: {
+          setData: data.map(({ pId }) => {return { idProduct: pId }}),
+          idCat: ''
+        }
+      }
+    })
+  }
+
+  return {
+    categories,
+    data: data?.catProductsAll ?? [],
+    loading,
+    error,
+    handlerDeleteCategoryInStore,
+    handleUpdateCatInProduct
+  }
+}

package/src/hooks/useCategoryInStore/queries.ts

@@ -0,0 +1,78 @@
+import { gql } from '@apollo/client'
+
+export const GET_ONE_STORE_IN_CATEGORY = gql`
+query getOneCatStore($catStore: ID){
+getOneCatStore(catStore: $catStore){
+  catStore
+  idUser
+  cName
+  cState
+  createdAt
+  cPathImage
+  updatedAt
+  csDescription
+  getAllStore {
+      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
+      }
+      getAllRatingStar {
+      rSId
+      rScore
+      idStore
+      createAt
+      
+    }
+  }
+  }
+}
+`

package/src/hooks/useCategoryStore/index.ts

@@ -0,0 +1,8 @@
+import { useQuery } from '@apollo/client'
+
+import { GET_ALL_CAT_STORE } from './queries'
+
+export const useCategoryStore = () => {
+  const { data, loading } = useQuery(GET_ALL_CAT_STORE)
+  return [data, { loading }]
+}

package/src/hooks/useCategoryStore/queries.ts

@@ -0,0 +1,16 @@
+import { gql } from '@apollo/client'
+
+export const GET_ALL_CAT_STORE = gql`
+query getAllCatStore{
+getAllCatStore{
+  catStore
+  idUser
+  cPathImage
+  cName
+  cState
+  createdAt
+  updatedAt
+  csDescription
+  }
+}
+`

package/src/hooks/useChartData/index.ts

@@ -0,0 +1,171 @@
+import { useQuery } from '@apollo/client'
+import { useState } from 'react'
+
+import { SPANISH_MONTHS } from '../../utils/index'
+import { GET_ALL_SALES } from '../useReport/queries'
+export * from './useChartDataAllOrders'
+
+export const useChartData = ({ year }) => {
+  const { data, loading } = useQuery(GET_ALL_SALES)
+  const [chartType, setChartType] = useState('line')
+  const [chartTypeYear, setChartTypeYear] = useState(new Date().getFullYear())
+  const [asFilter, setFilter] = useState(false)
+  const [newResult, setNewResult] = useState([])
+  const result = []
+  const sumByMonth = {}
+
+  data?.getAllSalesStore?.forEach(function (value) {
+    const month = new Date(value.pDatCre).getMonth()
+    const year = new Date(value.pDatCre).getFullYear()
+    const key = `${month}-${year}`
+
+    if (!sumByMonth[key]) {
+      sumByMonth[key] = {
+        Mes: month,
+        Year: year,
+        totalProductsPrice: 0
+      }
+
+      result.push(sumByMonth[key])
+    }
+
+    sumByMonth[key].totalProductsPrice += value.totalProductsPrice
+  })
+
+  const allMonths = Array.from({ length: 12 }, (_, i) => { return i })
+  const missingMonths = allMonths.filter(month => { return !result.some(data => { return data.Mes === month }) })
+
+  for (const element of missingMonths) {
+    result.push({
+      Mes: element,
+      totalProductsPrice: 0,
+      Year: ''
+    })
+  }
+
+  result.sort((a, b) => { return a.Mes - b.Mes })
+
+  const labelTitle = `Ventas por meses del año ${asFilter ? chartTypeYear : ''}`
+  // Resultado:
+  const dataChart = {
+    labels: asFilter
+      ? newResult.map(data => {
+        return SPANISH_MONTHS[data.Mes]
+      })
+      : result.map(data => {
+        return SPANISH_MONTHS[data.Mes]
+      }),
+    datasets: [
+      {
+        label: labelTitle,
+        data: asFilter ? newResult.map(data => { return data?.totalProductsPrice }) : result.map(data => { return data?.totalProductsPrice }),
+        backgroundColor: [
+          'rgba(255, 99, 132, 0.2)',
+          'rgba(54, 162, 235, 0.2)',
+          'rgba(255, 206, 86, 0.2)',
+          'rgba(75, 192, 192, 0.2)',
+          'rgba(153, 102, 255, 0.2)',
+          'rgba(255, 159, 64, 0.2)'
+        ],
+        borderColor: chartType === 'bar'
+          ? [
+            'rgba(255, 99, 132, 1)',
+            'rgba(54, 162, 235, 1)',
+            'rgba(255, 206, 86, 1)',
+            'rgba(75, 192, 192, 1)',
+            'rgba(153, 102, 255, 1)',
+            'rgba(255, 159, 64, 1)'
+          ]
+          : 'rgb(255 0 0)',
+        tension: 0.6,
+        fill: false,
+        borderWidth: 1,
+        barPercentage: 1,
+        barThickness: 50,
+        minBarLength: 3
+      }
+    ]
+  }
+  const options = {
+    interaction: {
+      mode: 'index',
+      intersect: false
+    },
+    scales: {
+      x: {
+        stacked: true
+      },
+      y: {
+        stacked: true
+      }
+    },
+    plugins: {
+      title: {
+        display: true,
+        text: labelTitle
+      }
+    }
+  }
+  const groupedData = {}
+
+  Boolean(data?.getAllSalesStore?.length) && data?.getAllSalesStore?.forEach((item) => {
+    const year = new Date(item.pDatCre).getFullYear()
+    if (!groupedData[year]) {
+      groupedData[year] = []
+    }
+    groupedData[year].push(item)
+  })
+  const years = []
+
+  Boolean(data?.getAllSalesStore?.length) && data?.getAllSalesStore?.forEach((item) => {
+    const y = new Date(item.pDatCre).getFullYear()
+    if (!years.includes(y)) {
+      years.push(y)
+    }
+  })
+  const handleChangeYear = (value) => {
+    setFilter(true)
+    const currentYear = parseInt(value)
+    setChartTypeYear(currentYear || '')
+    if (result?.length > 0) {
+      const filterToYear = result.filter((elem) => {
+        return elem?.Year === currentYear
+      })
+      const missingNewMonths = allMonths.filter(month => { return !filterToYear.some(data => { return data.Mes === month }) })
+      for (const element of missingNewMonths) {
+        filterToYear.push({
+          Mes: element,
+          totalProductsPrice: 0,
+          Year: ''
+        })
+      }
+      filterToYear.sort((a, b) => { return a.Mes - b.Mes })
+      setNewResult(filterToYear)
+      return filterToYear
+    }
+  }
+  const cleanFilter = () => {
+    setFilter(false)
+    setChartTypeYear(new Date().getFullYear())
+  }
+  const sortYear = () => {
+    return years.sort((a, b) => { return b - a })
+  }
+
+  const organiceYears = sortYear()
+  return {
+    handleChangeYear,
+    setFilter,
+    cleanFilter,
+    setChartType,
+    years: organiceYears,
+    asFilter,
+    chartTypeYear,
+    options,
+    chartType,
+    labelTitle,
+    result,
+    dataChart,
+    loading
+  }
+}