myprojplanet_vite/src/store/Products.ts

import type { IBaseOrder, ICart, IOrder, IOrderCart, IProduct, IProductsState, IProductInfo, ICatProd, IUserShort, IGasordine, IAuthor, ISubCatProd, IText, IOptCatalogo, ICatalog, ICatPrTotali, ISingleProductOrdered, ISchedaSingola, IMyScheda, IElementiScheda, T_Web_StatiProdotto, T_Web_Tipologie, T_WEB_TipiFormato, IPublisher, ICollaneTotali } from 'model'

import { Api } from '@api'
import { serv_constants } from '@src/store/Modules/serv_constants'
import * as Types from '@src/store/Api/ApiTypes'
import { static_data } from '@src/db/static_data'
import { shared_consts } from '@src/common/shared_vuejs'
import { tools } from '@store/Modules/tools'
import { defineStore } from 'pinia'
import { useUserStore } from '@store/UserStore'
import { toolsext } from '@store/Modules/toolsext'
import { useGlobalStore } from './globalStore'
import { ref } from 'vue'

import objectId from '@src/js/objectId'
import { costanti } from '@costanti'

import translate from '@src/globalroutines/util'
import { useCatalogStore } from './CatalogStore'

function getRecordOrdersCartEmpty(): IOrderCart {
  return {
    numorder: 0,
    numord_pers: 0,
    userId: '',
    user: null,
    totalQty: 0,
    totalPrice: 0,
    totalPriceCalc: 0,
    status: 0,
    confermato: false,
    consegnato: false,
    pagato: false,
    spedito: false,
    ricevuto: false,
    note: '',
    note_per_gestore: '',
    note_per_admin: '',
    note_ordine_gas: '',
  }
}

function getRecordProductInfoEmpty(): IProductInfo {
  return {
    code: '',
    name: '',
    description: '',
    department: '',
    catprods: [],
    subcatprods: [],
    color: '',
    size: '',
    weight: 0,
    unit: 0,
    stars: 0,
    date: tools.getDateNow(),
    icon: '',
    imagefile: '',
  }
}

function getRecordProductEmpty(): IProduct {

  const tomorrow = tools.getDateNow()
  tomorrow.setDate(tomorrow.getDate() + 1)

  return {
    productInfo: getRecordProductInfoEmpty(),
    // _id: tools.getDateNow().toISOString(),  // Create NEW
    active: false,
    idProducer: '',
    idStorehouses: [],
    idGasordine: '',
    idScontisticas: [],
    scontisticas: [],
    idProvider: '',
    producer: {},
    gasordine: null,
    storehouses: [],
    provider: {},
    price: 0.0,
    quantityAvailable: 0,
    bookableAvailableQty: 0,
    minBuyQty: 1,
    minStepQty: 1,
    maxBookableSinglePersQty: 0,

    stockQty: 0,
    stockBloccatiQty: 0,
    bookedQtyOrdered: 0,
    bookedQtyConfirmed: 0,

    qtyToReachForGas: 0,

    maxbookableGASQty: 0,
    bookedGASQtyOrdered: 0,
    bookedGASQtyConfirmed: 0,
    bookableGASBloccatiQty: 0,

    canBeShipped: false,
    QuantitaOrdinateInAttesa: 0,
    QuantitaPrenotateInAttesa: 0,
    canBeBuyOnline: false,
  }
}

export const useProducts = defineStore('Products', {
  state: (): IProductsState => ({
    products: [],
    cart: { items: [], totalPrice: 0, totalQty: 0, userId: '' },
    orders: [],
    catprods: [],
    catprods_gas: [],
    authors: [],
    publishers: [],
    subcatprods: [],
    productInfos: [],
    userActive: { username: '', name: '', surname: '', _id: '' },
  }),

  getters: {
    getCatProds: (state: IProductsState) => (cosa: number): ICatProd[] => {
      if (cosa === shared_consts.PROD.GAS)
        return state.catprods_gas
      else if (cosa === shared_consts.PROD.BOTTEGA)
        return state.catprods
      else
        return [...state.catprods, ...state.catprods_gas]

    },

    getCollane: (state: IProductsState) => (): ICollana[] => {
      return state.collane
    },

    isDisponibile: (state: IProductsState) => (product: IProduct): boolean => {
      return product?.arrvariazioni?.[0]?.quantita > 1
    },

    isDisponibilitaOk: (state: IProductsState) => (product: IProduct): boolean => {
      return product?.arrvariazioni?.[0]?.quantita > 100
    },

    isQtaLimitata: (state: IProductsState) => (product: IProduct): boolean => {
      return product?.arrvariazioni?.[0]?.quantita > 50 && product?.arrvariazioni?.[0]?.quantita < 100
    },

    isInEsaurendo: (state: IProductsState) => (product: IProduct): boolean => {
      return product?.arrvariazioni?.[0]?.quantita > 0 && product.arrvariazioni?.[0]?.quantita < 50
    },
    isEsaurito: (state: IProductsState) => (product: IProduct): boolean => {
      return product?.arrvariazioni?.[0]?.quantita <= 0 && !state.isProssimaUscitaById(product.productInfo.idStatoProdotto) && !state.isPrevenditaById(product.productInfo.idStatoProdotto)
    },

    isPubblicatoById: (state: IProductsState) => (idStatoProdotto: number): boolean => {
      /*
      1	In commercio
      3	Ristampa
      4	Prossima uscita/pubblicazione
      6	In promozione
      7	In fase di valutazione
      8	Titolo in esaurimento (in attesa Nuova Edizione)
      9	Titolo in esaurimento
      20	Titolo in esaurimento (in att N.E Ricopertinata)
      26	Titolo in Esaurimento (disponibile N.E.)
      33	In commercio (digitale)
      34	In prevendita
      45	Vendita sito
      46	2023 in commercio
      47	Assoluto NO Reso
      48	Titolo esaurito

      */

      switch (idStatoProdotto) {
        case 1: // In Commercio
        case 3: // Ristampa
        case 4: // Prossima uscita/pubblicazione
        case 6: // In promozione
        case 7: // In fase di valutazione
        case 8: // 8	Titolo in esaurimento (in attesa Nuova Edizione)
        case 9: // In Commercio
        case 33: // In commercio (digitale)
        case 34: // In prevendita
        case 45: // Vendita sito
        case 46: // 2023 in commercio
        case 47: // Assoluto NO Reso
        case 48: // Titolo esaurito
        case undefined:
          return true;
        default:
          return false;
      }
    },

    isProssimaUscitaById: (state: IProductsState) => (idStatoProdotto: number): boolean => {
      // 4 - Prossima uscita
      return (idStatoProdotto === 4)
    },
    isPrevenditaById: (state: IProductsState) => (idStatoProdotto: number): boolean => {
      // 4 - Prossima uscita
      // 34 - In Prevendita
      return (idStatoProdotto === 34)
    },
    isNovitaById: (state: IProductsState) => (date_pub: Date): boolean => {
      const sixMonthsAgo = new Date();
      sixMonthsAgo.setMonth(sixMonthsAgo.getMonth() - 6);
      return new Date(date_pub).getTime() > sixMonthsAgo.getTime();

    },

    isPubblicato: (state: IProductsState) => (productInfo: IProductInfo): boolean => {
      return state.isPubblicatoById(productInfo.idStatoProdotto)
    },

    isNovita: (state: IProductsState) => (productInfo: IProductInfo): boolean => {
      return state.isNovitaById(productInfo.date_pub)
    },

    isNonVendibile: (state: IProductsState) => (productInfo: IProductInfo): boolean => {
      return !state.isPubblicatoById(productInfo.idStatoProdotto) && !state.isProssimaUscitaById(productInfo.idStatoProdotto)
    },

    isProssimaUscita: (state: IProductsState) => (productInfo: IProductInfo): boolean => {
      return state.isProssimaUscitaById(productInfo.idStatoProdotto)
    },

    isPrevendita: (state: IProductsState) => (productInfo: IProductInfo): boolean => {
      return state.isPrevenditaById(productInfo.idStatoProdotto)
    },

    getDescrStatiProdottoByIdStatoProdotto: (state: IProductsState) => (idStatoProdotto: number): string => {
      const ctrec = state.stati_prodotto.find((mystatus: T_Web_StatiProdotto) => mystatus.IdStatoProdotto === idStatoProdotto)
      return (ctrec) ? ctrec.Descrizione : ''
    },

    getCasaEditriceByIdPublisher: (state: IProductsState) => (idPublisher: string): string => {
      const rectrovato: IPublisher = state.publishers.find((editore: IPublisher) => editore._id === idPublisher)
      return (rectrovato) ? rectrovato.name : ''
    },


    getDescrByIdTipologia: (state: IProductsState) => (idTipologia: number): string => {
      const ctrec = state.tipologie.find((mystatus: T_Web_Tipologie) => mystatus.IdTipologia === idTipologia)
      return (ctrec) ? ctrec.Descrizione : ''
    },

    getDescrByIdTipoFormato: (state: IProductsState) => (idTipoFormato: number): string => {
      const ctrec = state.tipoformato.find((mystatus: T_WEB_TipiFormato) => mystatus.IdTipoFormato === idTipoFormato)
      return (ctrec) ? ctrec.Descrizione : ''
    },


    getArrayidArgomentoByArridCatProds: (state: IProductsState) => (arridCatProds: string[]): string[] => {
      const myarr: string[] = []
      for (const idCatProd of arridCatProds) {
        const catprod = state.catprods.find((rec: ICatProd) => rec._id === idCatProd)
        if (catprod && catprod.idArgomento && !myarr.includes(catprod.idArgomento.toString())) {
          myarr.push(catprod.idArgomento.toString())
        }
      }
      return myarr
    },

    getCatProdsByGas: (state: IProductsState) => (idGasOrdine: string): ICatProd[] => {
      let arrcat = state.catprods_gas

      // Ottieni le categorie solo per i "products" che hanno come idGasOrdine il valore passato
      if (idGasOrdine) {
        arrcat = state.catprods_gas.filter((rec: ICatProd) => {
          const arrprod = state.products.filter((prod: IProduct) => {
            if (prod.idGasordine === idGasOrdine && prod.productInfo.idCatProds?.includes(rec._id)) {
              return true
            }

          })
          return arrprod.length > 0 ? true : false
        })

      } else {
        return []
      }


      return arrcat
    },

    getCatProdsStrByCatProds: (state: IProductsState) => (catProds: ICatProd[]): string => {
      let mystr = ''
      for (const catprod of catProds) {
        let myarrcat = null
        if (tools.isObject(catprod)) {
          myarrcat = catprod
        } else {
          myarrcat = state.catprods.find((rec: ICatProd) => rec._id === catprod)
        }
        if (myarrcat) {
          if (mystr)
            mystr += ' - '
          mystr += myarrcat.name
        }
      }
      return mystr
    },

    getSubCatProdsStrBySubCatProds: (state: IProductsState) => (idSubCatProds: string[]): string => {
      let mystr = '';
      if (Array.isArray(idSubCatProds) && idSubCatProds.length > 0) {
        const names = idSubCatProds.map(id => {
          const subCatProd = state.subcatprods.find((rec: ISubCatProd) => rec._id === id);
          return subCatProd ? subCatProd.name : '';
        }).filter(name => name !== '');

        mystr = names.join(' - ');
      }
      return mystr;
    },

    getTotaleOrdineByOrdId: (state: IProductsState) => (idOrdine: string, idGasordine: string, totale: boolean, mostra_solo_ordini_produttore: boolean, status: number): number => {

      let arrprod = []

      if (totale) {
        arrprod = state.orders.filter((rec: IOrderCart) => {
          if (idGasordine && !rec.items?.some(item => item.order && item.order.idGasordine === idGasordine) || (rec.status !== status)) {
            return false; // Skip records not matching gasordine condition
          }
          return true;
        });

      } else {
        arrprod = state.orders.filter((rec: IOrderCart) => {
          if (idGasordine && !rec.items?.some(item => item.order && item.order.idGasordine === idGasordine) || (rec._id !== idOrdine)) {
            return false; // Skip records not matching gasordine condition
          }
          return true;
        });
        }

      let subtotalPrice = 0

      arrprod.forEach((rec: IOrderCart) => {
        rec.items?.forEach(item => {
          if (item.order && ((mostra_solo_ordini_produttore && (item.order.idGasordine === idGasordine)) || !mostra_solo_ordini_produttore)) {
            const qtyparz = item.order.quantity + item.order.quantitypreordered
            subtotalPrice += item.order.price * qtyparz
          }
        });
      });

      return subtotalPrice;
    },

    getCatProdDescrStrByIdCatProd: (state: IProductsState) => (idCatProd: string): string => {
      const myfirstcat = state.catprods.find((rec: ICatProd) => rec._id === idCatProd)

      if (myfirstcat) {
        return myfirstcat.descr_estesa!
      }
      return ''
    },
    getTotaliProdottiByIdCatProd: (state: IProductsState) => (idCatProd: string): number => {
      const myfirstcat = state.catprtotali!.find((rec: ICatPrTotali) => rec._id === idCatProd)

      if (myfirstcat) {
        return myfirstcat.quanti!
      }
      return 0
    },

    getTotaliProdottiByIdCollana: (state: IProductsState) => (idCollana: string): number => {
      const myfirstcat = state.collane.find((rec: ICollaneTotali) => rec._id === idCollana)

      if (myfirstcat) {
        return myfirstcat.quanti!
      }
      return 0
    },


    getSubCatProdsByGas: (state: IProductsState) => (idGasOrdine: string, idCatProd: string): ISubCatProd[] => {
      let arrcat = state.subcatprods

      // Ottieni le categorie solo per i "products" che hanno come idGasOrdine il valore passato
      if (idGasOrdine) {
        arrcat = state.subcatprods.filter((rec: ISubCatProd) => {
          const arrprod = state.products.filter((prod: IProduct) => {
            if (prod.idGasordine === idGasOrdine
              && prod.productInfo.idSubCatProds?.includes(rec._id)
              && prod.productInfo.idCatProds?.includes(idCatProd)
            ) {
              return true
            }

          })
          return arrprod.length > 0 ? true : false
        })

      } else {
        return []
      }
      return arrcat
    },

    getAuthors: (state: IProductsState) => (): any[] => {
      // Get the list of authors, for the q-select component using state.authors array
      // [{name: xxx, value: _id }]

      // add default value for q-select
      const options = [
        {
          label: '[Tutti]',
          value: '',
        },
        ...state.authors.map((rec: IAuthor) => {
          return { label: rec.name + (rec.surname ? ' ' + rec.surname : ''), value: rec._id }
        }),
      ]
      return options
    },


    getNumProdTot: (state: IProductsState) => (): number => {
      return state.products.length
    },

    getProducts: (state: IProductsState) => (cosa?: number): IProduct[] => {
      if (!!cosa) {
        return state.products.filter((rec: IProduct) => {
          const hasGasOrdines = rec.idGasordine

          if ((cosa === shared_consts.PROD.GAS && hasGasOrdines) ||
            (cosa === shared_consts.PROD.BOTTEGA && (!hasGasOrdines))) {
            return true;
          }

          return false;
        });
      } else {
        return state.products;
      }
    },

    updateDataProduct: (state: IProductsState) => (res: any) => {
      if (res && res.data.product) {
        // Update product from server
        const indelem = state.products.findIndex((prod: IProduct) => prod._id === res.data.product._id)
        if (indelem >= 0) {
          state.products[indelem] = { ...res.data.product }

          /*if (!res.data.orders) {
            // aggiorna anche tutti i product negli ordini !
            let ordcart: IOrderCart
            for (ordcart of state.orders) {
              for (const item of ordcart.items!) {
                if (item.order.idProduct === res.data.product.idProduct)
                  item.order.product = res.data.product
              }
            }
          }*/
        }
      }
      if (res && res.data.orders) {
        state.orders = res.data.orders
      }

      if (res && res.data.cart) {  // console.log('RISULTANTE CATEGORIES DAL SERVER = ', res.data.categories)
        state.cart = res.data.cart
      }

    },
    getProductByCode: (state: IProductsState) => (code: string): IProduct => {
      if (!code) {
        return getRecordProductEmpty()
      }

      const prod = state.products.find((prod: IProduct) => {
        if (prod.productInfo.code === code)
          return prod
        else
          return null
      })
      return prod ? prod : getRecordProductEmpty()
    },

    getCart: (state: IProductsState) => (): ICart => {
      return state.cart
    },

    getOrdersAllCart: (state: IProductsState) => (idGasordine: string): IOrderCart[] => {
      return state.orders.filter((rec: IOrderCart) => {
        if ((idGasordine && !rec.items?.some(item => item.order && item.order.idGasordine === idGasordine))) {
          return false; // Skip records not matching gasordine condition
        }
        return true
      })
    },

    getNumOrders: (state: IProductsState) => (): number => {
      return state.orders.length
    },

    getOrdersCart: (state: IProductsState) => (tipoord: number, hasGasordine: any, idGasordine: string): IOrderCart[] | undefined => {
      return state.orders.filter((rec: IOrderCart) => {
        if (idGasordine && !rec.items?.some(item => item.order && item.order.idGasordine === idGasordine)) {
          return false; // Skip records not matching gasordine condition
        }

        if (hasGasordine && !rec.items?.some(item => item.order && item.order.idGasordine)) {
          return false; // Skip records not matching gasordine condition
        }

        switch (tipoord) {
          case shared_consts.OrderStat.IN_CORSO.value:
            return !rec.status || rec.status <= shared_consts.OrderStatus.CHECKOUT_SENT;
          case shared_consts.OrderStat.PREPARED.value:
            return rec.status === shared_consts.OrderStatus.PREPARED;
          case shared_consts.OrderStat.CONFERMATI.value:
            return rec.status === shared_consts.OrderStatus.ORDER_CONFIRMED;
          case shared_consts.OrderStat.PAGATI.value:
            return rec.status === shared_consts.OrderStatus.PAYED;
          case shared_consts.OrderStat.DELIVERED.value:
            return rec.status === shared_consts.OrderStatus.DELIVERED;
          case shared_consts.OrderStat.SHIPPED.value:
            return rec.status === shared_consts.OrderStatus.SHIPPED;
          case shared_consts.OrderStat.RECEIVED.value:
            return rec.status === shared_consts.OrderStatus.RECEIVED;
          case shared_consts.OrderStat.COMPLETATI.value:
            return rec.status === shared_consts.OrderStatus.COMPLETED;
          case shared_consts.OrderStat.CANCELLATI.value:
            return rec.status === shared_consts.OrderStatus.CANCELED;
          default:
            return false; // Invalid tipoord
        }
      });
    },

    existProductInCart: (state: IProductsState) => (idproduct: string): boolean => {
      // console.log('.cart.items', this.cart.items)
      if (state.cart.items) {
        const ris = state.cart.items.filter((item: IBaseOrder) => item.order.idProduct === idproduct).reduce((sum, rec) => sum + 1, 0)
        return ris > 0
      }
      return false
    },
    getOrderProductInCart: (state: IProductsState) => (idproduct: string): IOrder | null => {
      // console.log('.cart.items', this.cart.items)
      if (state.cart.items) {
        const ris = state.cart.items.find((item: IBaseOrder) => item.order ? (item.order.idProduct === idproduct) : false)
        return ris ? ris.order : null
      }
      return null
    },

    getOrderProductInOrdersCart: (state: IProductsState) => (idordercart: string, idproduct: string): IOrder | null => {
      // console.log('.cart.items', this.cart.items)
      if (state.orders) {
        const orderscart = state.orders.find((rec: IOrderCart) => rec._id === idordercart)
        if (orderscart) {
          const ris = orderscart.items!.find((item: IBaseOrder) => item.order.idProduct === idproduct)
          return ris ? ris.order : null
        }
      }
      return null
    },

    getOrdersCartById: (state: IProductsState) => (idordercart: string): IOrderCart => {
      if (state.orders) {
        const orderscart = state.orders.find((rec: IOrderCart) => rec._id === idordercart)
        return orderscart ?? getRecordOrdersCartEmpty()
      }
      return getRecordOrdersCartEmpty()
    },

    getSumQtyPreOrderInOrdersCart: (state: IProductsState) => (idproduct: string): number => {
      let totalQuantity = 0;

      if (state.orders) {
        const orderscart = state.orders
        if (orderscart) {
          for (const myord of orderscart) {
            if (myord.items) {
              for (const item of myord.items) {
                if (item.order) {
                  if ((item.order.idProduct === idproduct) && (item.order.status! < shared_consts.OrderStatus.CHECKOUT_SENT)) {
                    totalQuantity += (item.order.quantitypreordered) || 0;
                  }
                }
              }
            }
          }
        }
      }
      return totalQuantity
    },

    getSumQtyOrderProductInOrdersCart: (state: IProductsState) => (idproduct: string): number => {
      let totalQuantity = 0;

      if (state.orders) {
        const orderscart = state.orders
        if (orderscart) {
          for (const myord of orderscart) {
            if (myord.items) {
              for (const item of myord.items) {
                if (item.order) {
                  if ((item.order.idProduct === idproduct) && (item.order.status! < shared_consts.OrderStatus.CHECKOUT_SENT)) {
                    totalQuantity += (item.order.quantity) || 0;
                  }
                }
              }
            }
          }
        }
      }
      return totalQuantity
    },

    getOrdersCartByIdProduct: (state: IProductsState) => (idproduct: string): IOrderCart[] | [] => {
      try {
        if (state.orders) {
          const ris = state.orders.filter((orderscart: IOrderCart) => {
            return orderscart.items!.some(item => {
              if (item.order)
                return (item.order.idProduct === idproduct)
                  && (item.order.status! < shared_consts.OrderStatus.CHECKOUT_SENT)
            })
          })
          // console.log('Ordini ', ris)
          return ris ? ris : []
        }
      } catch (e) {
        console.error('Err', e)
      }
      return []
    },

    getOrdersCartInAttesaByIdProduct: (state: IProductsState) => (idproduct: string): IOrderCart[] | [] => {
      try {
        if (state.orders) {
          const ris = state.orders.filter((orderscart: IOrderCart) => {
            return orderscart.items!.some(item => {
              if (item.order)
                return (item.order.idProduct === idproduct)
                  && (item.order.status! <= shared_consts.OrderStatus.CHECKOUT_SENT)
            })
          })
          // console.log('Ordini ', ris)
          return ris ? ris : []
        }
      } catch (e) {
        console.error('Err', e)
      }
      return []
    },


    getRecordEmpty: (state: IProductsState) => (): IProduct => {
      return getRecordProductEmpty()
    },

  },

  actions: {

    createOrderByProduct(product: IProduct, order: IOrder): IOrder {
      const userStore = useUserStore()
      const myorder: IOrder = {
        userId: this.userActive._id,
        idapp: import.meta.env.VITE_APP_ID,
        status: shared_consts.OrderStatus.IN_CART,
        TotalPriceProduct: 0,
        TotalPriceProductCalc: 0,
        idProduct: product._id,
        product,  // Copia tutto l'oggetto Product !

        // Ordine:
        price: product.price,
        after_price: product.after_price,
        quantity: order.quantity,
        quantitypreordered: order.quantitypreordered,
        idStorehouse: order.idStorehouse,
        idGasordine: order.idGasordine,
        //++Add Fields
      }

      return myorder
    },

    initcat() {

      // rec.userId = this.userActive._id

      return this.getRecordEmpty()

    },

    /*resetProducts() {
      const arrprod = [...this.products]
      this.products = []
      this.products = [...arrprod]
    },*/

    async getProductById(id: string, forza?: boolean): Promise<IProduct> {
      let prod = null
      try {
        if (!id) {
          return null
        }
        if (!this.products || forza) {
          // Se non lo carico all'avvio, allora fai la chiamata al server
          prod = await this.loadProductById(id)
        } else {
          prod = this.products.find((prod: IProduct) => prod._id === id)
        }
      } catch (e) {
        console.error('Err', e)
      }

      return prod ? prod : getRecordProductEmpty()
    },


    async loadProducts(loadonlyifempty?: boolean) {

      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      //console.log('loadProducts')

      // if (!globalStore.site.confpages.enableEcommerce)
      //   return null

      // console.log('getProducts', 'userid=', this.userActive._id)

      // if (this.userActive._id === '') {
      //   return new Types.AxiosError(0, null, 0, '')
      // }

      if (loadonlyifempty) {
        if (this.products?.length > 0)
          return true
      }

      let ris = null

      let myIdActiveSelected = userStore.my._id
      if (tools.isSeller())
        myIdActiveSelected = tools.getCookie(tools.COOK_SELCART, userStore.my._id, false)

      const trovato = userStore.usersList.find((user: IUserShort) => user._id === myIdActiveSelected)
      if (trovato)
        this.userActive = trovato
      else
        this.userActive = userStore.my

      console.log('userActive', this.userActive)

      ris = await Api.SendReq('/products', 'POST', { userId: this.userActive._id })
        .then((res) => {
          if (res.data.products) {
            // console.log('aggiorna prodotti')
            this.products = []
            this.products = res.data.products
          } else {
            this.products = []
          }

          if (res.data.orders) {
            this.orders = []
            this.orders = res.data.orders
          } else {
            this.orders = []
          }

          return res
        })
        .catch((error) => {
          console.log('error getProducts', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      // ApiTables.aftercalling(ris, checkPending, 'categories')

      return ris
    },

    async updateOrderByOrder(idOrdersCart: string, idOrder: string, paramstoupdate: any) {

      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      // console.log('loadProducts')

      if (!globalStore.site.confpages.enableEcommerce)
        return null

      console.log('updateOrderByOrder', 'userid=', this.userActive._id)

      let ris = null

      ris = await Api.SendReq('/orders/updateord', 'POST', { idOrdersCart, idOrder, paramstoupdate })
        .then((res) => {
          let myorderscart = res.data.orderscart
          if (res) {
            myorderscart = res.data && res.data.orderscart ? res.data.orderscart : null
            if (myorderscart) {
              const idord = this.orders.findIndex((ord: IOrderCart) => ord._id === myorderscart._id)
              if (idord >= 0) {
                console.log('aggiorna ordine')
                this.orders[idord] = { ...myorderscart }
              }
            }
          }
          return myorderscart
        })
        .catch((error) => {
          console.log('error updateOrderByOrder', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      // ApiTables.aftercalling(ris, checkPending, 'categories')

      return ris
    },

    async updateOrdersCartById(idOrdersCart: string, paramstoupdate: any) {

      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      // console.log('loadProducts')

      if (!globalStore.site.confpages.enableEcommerce)
        return null

      console.log('updateOrdersCartById', 'userid=', this.userActive._id)

      let ris = null

      ris = await Api.SendReq('/orders/update', 'POST', { idOrdersCart, paramstoupdate })
        .then((res) => {
          let myorderscart = res.data.orderscart
          if (res) {
            if (myorderscart) {
              const idord = this.orders.findIndex((ord: IOrderCart) => ord._id === myorderscart._id)
              if (idord >= 0) {
                console.log('aggiorna orderscart')
                this.orders[idord] = myorderscart
              }
            }
          }
          return myorderscart
        })
        .catch((error) => {
          console.log('error updateOrderByOrder', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      // ApiTables.aftercalling(ris, checkPending, 'categories')

      return ris
    },

    async loadProductById(id: string) {

      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      //if (!globalStore.site.confpages.enableEcommerce)
      //  return null

      // if (this.userActive._id === '') {
      //   return new Types.AxiosError(0, null, 0, '')
      // }

      let ris = null

      ris = await Api.SendReq('/products/id/' + id, 'GET', null)
        .then((res) => {
          console.log('product', res.data.product)
          if (res.data.product) {  // console.log('RISULTANTE CATEGORIES DAL SERVER = ', res.data.categories)
            this.updateDataProduct(res)
            return res.data.product
          } else {
            return null
          }
        })
        .catch((error) => {
          console.log('error getProduct', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      return ris
    },


    async loadOrders() {

      // console.log('loadOrders')
      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      if (!globalStore.site.confpages.enableEcommerce)
        return null

      if (!this.userActive._id)
        return null

      // if (this.userActive._id === '') {
      //   return new Types.AxiosError(0, null, 0, '')
      // }

      let ris = null

      ris = await Api.SendReq('/cart/' + this.userActive._id, 'GET', null)
        .then((res) => {
          if (res.data && res.data.cart) {  // console.log('RISULTANTE CATEGORIES DAL SERVER = ', res.data.categories)
            this.cart = res.data.cart
          } else {
            this.cart = { items: [], totalPrice: 0, totalQty: 0, userId: '' }
          }

          this.updateDataProduct(res)

          return res
        })
        .catch((error) => {
          console.log('error loadOrders', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      // ApiTables.aftercalling(ris, checkPending, 'categories')
      return ris
    },


    async removeFromCart({ order }: { order: IOrder }) {

      const userStore = useUserStore()

      return Api.SendReq('/cart/' + this.userActive._id, 'DELETE', { orderId: order._id })
        .then((res) => {
          this.updateDataProduct(res)

          return res
        })
    },

    async getGestoreOrdini({ idGasordine }: { idGasordine: string }) {
      const userStore = useUserStore()

      let useractive = this.userActive._id
      if (!useractive)
        useractive = userStore.my._id;

      return Api.SendReq('/cart/' + useractive + '/gestord', 'POST', { idGasordine })
        .then((res) => {
          if (res)
            return res.data.arrout
          else
            return []

        })
    },

    async addToCart({ product, order, addqty }: { product: IProduct, order: IOrder, addqty: boolean }) {

      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      if (!globalStore.site.confpages.enableEcommerce)
        return null

      let neworder = null;

      // Controlla se esiste già nel carrello, allora semplicemente aggiungerò la quantità:
      if (this.existProductInCart(product._id)) {
        const ordcart = this.getOrderProductInCart(product._id)
        if (ordcart) {

          if (!addqty && ((ordcart.quantity + ordcart.quantitypreordered) === 1)) {
            // sto per rimuovere l'ultimo pezzo, quindi cancello direttamente
            const risrem = await this.removeFromCart({ order: ordcart })

            if (risrem) {
              order.quantity = 0
              order.quantitypreordered = 0
              return true
            } else {
              return false
            }
          }

          return await this.addSubQtyToItem({
            addqty,
            subqty: !addqty,
            order: ordcart,
          }).then((res: any) => {
            if (res && res.msgerr) {
              return res;
            } else if (res && res.risult) {
              order.quantity = res.myord.quantity
              order.quantitypreordered = res.myord.quantitypreordered
            }
            return res;
          })
        }
      } else {
        if (this.isQtyAvailableByProduct(product)) {
          order.quantity = product.minBuyQty || 1
          order.quantitypreordered = 0
        } else {
          if (this.isInPreorderByProduct(product)) {
            order.quantitypreordered = product.minBuyQty || 1
            order.quantity = 0
          }
        }

        if (!order.idStorehouse) {
          if (product.storehouses.length === 1) {
            order.idStorehouse = product.storehouses[0]._id
          } else {
            try {
              order.idStorehouse = globalStore.storehouses?.length ? globalStore.storehouses[0]._id : ''
            } catch (e) {

            }
          }
        }
        if (!order.idGasordine && order.quantitypreordered > 0) {
          if (product.gasordine && product.gasordine._id) {
            order.idGasordine = product.gasordine._id
          } else {
            order.idGasordine = globalStore.gasordines?.length ? globalStore.gasordines[0]._id : ''
          }
        }

        if (order.idStorehouse) {
          neworder = this.createOrderByProduct(product, order)
        }
      }

      // if (neworder && !neworder.idStorehouse)
      //   return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, 'Nessuno Store')

      console.log('addToCart', 'userid=', this.userActive._id, neworder)

      let ris = null

      ris = await Api.SendReq('/cart/' + this.userActive._id, 'POST', { order: neworder })
        .then((res) => {
          if (res.data.cart) {  // console.log('RISULTANTE CATEGORIES DAL SERVER = ', res.data.categories)
            this.cart = res.data.cart
          } else {
            this.cart = { items: [], totalPrice: 0, totalQty: 0, userId: '' }
          }
          this.updateDataProduct(res)

          return { risult: !!res, myord: res.data.myord, msgerr: res.data.msgerr }
        })
        .catch((error) => {
          console.log('error addToCart', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      // ApiTables.aftercalling(ris, checkPending, 'categories')

      return ris
    },

    async addSubQtyToItem({ addqty, subqty, order }: { addqty: boolean, subqty: boolean, order: IOrder }) {

      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      if (!globalStore.site.confpages.enableEcommerce)
        return null

      // console.log('addSubQtyToItem', 'userid=', this.userActive._id, order)

      let ris = null

      ris = await Api.SendReq('/cart/' + this.userActive._id, 'POST', { addqty, subqty, order })
        .then((res: any) => {
          this.updateDataProduct(res)

          return { risult: !!res, myord: res.data.myord, msgerr: res.msgerr }
        })
        .catch((error) => {
          console.log('error addSubQtyToItem', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      // ApiTables.aftercalling(ris, checkPending, 'categories')

      return ris
    },

    getOptions(sendmail: boolean) {
      return {
        sendmail
      }
    },

    async CreateOrdersCart({ cart_id, status, note }: { cart_id: string, status: number, note: string }) {

      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      if (!globalStore.site.confpages.enableEcommerce)
        return null

      if (!this.userActive._id)
        return null

      let ris = null

      ris = await Api.SendReq('/cart/' + this.userActive._id + '/createorderscart', 'POST', { cart_id, status, note, options: this.getOptions(true) })
        .then((res) => {

          if (res.data.status === shared_consts.OrderStatus.CHECKOUT_SENT) {
            // Cancella il Carrello, ho creato l'ordine !
            this.cart = {}
          }

          this.updateDataProduct(res)

          return res.data.recOrderCart
        })
        .catch((error) => {
          console.log('error UpdateStatusCart', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      return ris
    },

    /*async UpdateStatusCart({ ordercart_id, status }: { ordercart_id: string, status: number }) {

      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      if (!globalStore.site.confpages.enableEcommerce)
        return null

      let ris = null

      ris = await Api.SendReq('/cart/updatestatuscart', 'POST', { ordercart_id, status, options: this.getOptions() })
        .then((res) => {

          if (res.data.status === shared_consts.OrderStatus.CHECKOUT_SENT) {
            this.cart = {}
          }
          this.updateDataProduct(res)

          return res.data.status
        })
        .catch((error) => {
          console.log('error UpdateStatusCart', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      return ris
    },*/

    async UpdateOrderCartStatus({ order_id, status, sendmail }: { order_id: string, status: number, sendmail: boolean }) {

      const userStore = useUserStore()
      const globalStore = useGlobalStore()

      if (!globalStore.site.confpages.enableEcommerce)
        return null

      let ris = null

      ris = await Api.SendReq('/cart/' + this.userActive._id + '/ordercartstatus', 'POST', { order_id, status, options: this.getOptions(sendmail) })
        .then((res) => {

          this.updateDataProduct(res)

          return res.data.status

        })
        .catch((error) => {
          console.log('error UpdateOrderCartStatus', error)
          userStore.setErrorCatch(error)
          return new Types.AxiosError(serv_constants.RIS_CODE_ERR, null, toolsext.ERR_GENERICO, error)
        })

      return ris
    },
    async addtoCartBase({ $q, t, id, order, addqty }: { $q: any, t: any, id: string, order: IOrder, addqty: boolean }) {
      let product = await this.getProductById(id)

      return await this.addToCart({ product, order, addqty })
        .then((ris) => {
          if (ris && ris.msgerr) {
            tools.showNegativeNotif($q, ris.msgerr)
          } else {
            let strprod = t('ecomm.prodotto')

            let msg = ''
            console.log('ris', ris)
            if (ris && ris.myord == null) {
              msg = t('ecomm.prodotto_tolto')
              tools.showNotif($q, msg)
              return
            }
            if (ris === null || ris.myord == null) {
              msg = t('ecomm.error_cart')
              tools.showNegativeNotif($q, msg)
              return
            } else {

              let qta = ris.myord.quantity + ris.myord.quantitypreordered
              if (qta > 1 || qta === 0)
                strprod = t('ecomm.prodotti')


              if (qta >= 0) {
                let totalPrice = this.cart.totalPrice ? this.cart.totalPrice.toFixed(2) : 0
                let tot = totalPrice + ' €'
                msg = t('ecomm.prod_sul_carrello', { strprod, qty: qta, tot })
              }

            }
            if (ris === null || ris.myord.quantity === 0)
              tools.showNotif($q, msg)
            else
              tools.showPositiveNotif($q, msg, undefined, 'prodotto')


          }
          //updateproduct()

          return ris
        })
    },

    getQuantityByOrder($t: any, order: IOrder): string {
      let mystr = '';
      if (order.quantity > 0) {
        mystr += order.quantity
      }
      if ((order.quantitypreordered > 0) && (order.quantity > 0)) {
        mystr += ' ' + $t('ecomm.available')
        mystr += ' + '
      }
      if (order.quantitypreordered > 0) {
        mystr += ' ' + order.quantitypreordered + ' ';
      }
      return mystr
    },

    isQtyAvailableByProduct(product: IProduct): boolean {
      if (product) {
        return (product.quantityAvailable! > 0)
      }
      return false;
    },

    isInPreorderByProduct(product: IProduct): boolean {
      if (product) {
        return (product.bookableAvailableQty! > 0)
      }
      return false;
    },

    isQtyAvailableByOrder(order: IOrder): boolean {
      if (order && order.product) {
        return this.isQtyAvailableByProduct(order.product)
      }
      return false;
    },

    isInPreorderByOrder(order: IOrder): boolean {
      if (order && order.product) {
        return this.isInPreorderByProduct(order.product)
      }
      return false;
    },

    getSingleGasordine(order: IOrder, short: boolean): string {
      try {
        const mygas = order.gasordine
        if (mygas) {
          if (short)
            return mygas.name!
          else
            return mygas.name + ' (' + mygas.city + ') ' + translate('gas.dataora_chiusura_ordini') + ': ' + tools.getstrDateShort(mygas.dataora_chiusura_ordini)
              + ' ' + translate('gas.data_arrivo_merce') + ': ' + tools.getstrDateShort(mygas.data_arrivo_merce)
              + ' ' + translate('gas.dataora_ritiro') + ': ' + tools.getstrDateShort(mygas.dataora_ritiro)
        } else
          return ''
      } catch (e) {
        return ''
      }
    },

    getQtyAvailable(myproduct: IProduct): number {
      let qty = myproduct.quantityAvailable!
      return qty
    },

    getQtyBookableAvailable(myproduct: IProduct): number {
      let qty = myproduct.bookableAvailableQty!
      return qty
    },

    getQtyBloccataAvailable(myproduct: IProduct): number {
      let qty = myproduct.stockBloccatiQty
      return qty
    },

    getQtyBloccataBookableAvailable(myproduct: IProduct): number {
      let qty = myproduct.bookableGASBloccatiQty
      return qty
    },

    enableSubQty(myorder: IOrder): boolean {
      let qty = myorder.quantity + myorder.quantitypreordered
      return qty ? qty > 0 : false
    },

    CanDeleteIfSub(myorder: IOrder): boolean {
      let qty = myorder.quantity + myorder.quantitypreordered

      qty = qty - this.qtaNextSub(myorder, myorder.product!)
      return qty === 0
    },

    enableAddQty(myorder: IOrder, myproduct: IProduct): boolean {
      const globalStore = useGlobalStore()
      if (globalStore.site.ecomm && globalStore.site.ecomm.enablePreOrders) {
        return ((this.getQtyBookableAvailable(myproduct) > 0)
          && (myproduct.maxBookableSinglePersQty === 0
            || (myorder.quantitypreordered + 1 < myproduct.maxBookableSinglePersQty))
        )
          || (this.getQtyAvailable(myproduct) > 0)
          && (myproduct.maxBookableSinglePersQty === 0
            || (myorder.quantity + 1 < myproduct.maxBookableSinglePersQty))

      } else {
        return (this.getQtyAvailable(myproduct) > 0)
          && (myproduct.maxBookableSinglePersQty === 0
            || (myorder.quantity + 1 < myproduct.maxBookableSinglePersQty))
      }

    },

    qtaNextAdd(myorder: IOrder, myproduct: IProduct): number {
      let step = myproduct.minStepQty
      if (this.getQtyAvailable(myproduct) > 0) {
        if (myorder.quantity === 0)
          step = myproduct.minBuyQty
      } else {
        if (myorder.quantitypreordered === 0)
          step = myproduct.minBuyQty
      }

      if (step === 0) {
        step = 1
      }

      return step
    },

    qtaNextSub(myorder: IOrder, myproduct: IProduct) {
      let step = myproduct.minStepQty
      let minqta = myproduct.minBuyQty
      if (this.getQtyAvailable(myproduct) > 0) {
        if (myorder.quantity === minqta)
          step = minqta
      } else {
        if (myorder.quantitypreordered === minqta)
          step = minqta
      }

      return step
    },

    getNumQtaGas() {
      const arrprod = this.getProducts(shared_consts.PROD.GAS)
      return arrprod.length
    },

    getNumQtaTutti() {
      const arrprod = this.getProducts(shared_consts.PROD.TUTTI)
      return arrprod.length
    },

    getNumQtaBottega() {
      const arrprod = this.getProducts(shared_consts.PROD.BOTTEGA)
      return arrprod.length
    },

    changeuserActive(valuerec: any) {
      if (valuerec) {
        console.log('valuerec', valuerec)
        tools.setCookie(tools.COOK_SELCART, valuerec._id)
        this.products = []
        this.orders = []
        this.cart = { items: [], totalPrice: 0, totalQty: 0, userId: '' }

        this.loadOrders()
        this.loadProducts()
      }
    },

    async sendMailToTheBuyer(idOrdersCart: string, templemail_id: string, test: boolean) {
      return await Api.SendReq('/orders/sendmail', 'POST', { templemail_id, idOrdersCart, previewonly: tools.isDebug(), test })
        .then((res) => {
          console.log('res', res)
          if (res)
            return res.data
          else
            return null
        })
    },


    getStrInfoOrder(t: any, order: IOrder) {
      let mystr = ''
      let qtyrisult: any

      if (order.product) {
        let qtystr = ''
        let qtynum = 0
        if (order.quantity > 0)
          qtynum += order.quantity;
        if (order.quantitypreordered > 0)
          qtynum += order.quantitypreordered;

        if (order.product.productInfo.sfuso && order.product.productInfo.weight)
          qtyrisult = qtynum * order.product.productInfo.weight;
        else
          qtyrisult = qtynum + ' x ' + order.product.productInfo.weight;

        qtystr += qtyrisult + ' ' + tools.getUnitsMeasure(order.product.productInfo.unit, true, order.product.productInfo.weight);

        if (order.quantitypreordered > 0)
          qtystr += ' Pre-Ordinati';

        mystr += '✅ [' + qtystr + '] ' + order.product.productInfo.name + ' a ' + order.price + '€ ' + (order.after_price ? order.after_price : '') + '<br>Totale = ' + order.TotalPriceProduct + '€';

      }
      return mystr
    },

    getGasordineNameById(idGasordine: string) {

      const globalStore = useGlobalStore()
      const rec = globalStore.gasordines.find((gasordine: IGasordine) => gasordine._id === idGasordine)
      return rec ? rec.name : ''

    },

    getGasordines() {
      const globalStore = useGlobalStore()

      const myarr: any = [{
        id: 0,
        label: 'Tutti',
        value: ''
      }]
      let ind = 1
      if (globalStore.gasordines) {
        globalStore.gasordines.forEach((gasordine: IGasordine) => {
          if (gasordine) {
            myarr.push(
              {
                id: ind,
                label: gasordine.name
                  + (gasordine.dataora_chiusura_ordini ? (' - chiusura: ' + tools.getstrDateShort(gasordine.dataora_chiusura_ordini)) : '')
                  + (gasordine.dataora_ritiro ? (' - consegna ' + tools.getstrDateShort(gasordine.dataora_ritiro)) : '')
                ,
                value: gasordine._id
              })
            ind++
          }
        })
      }

      return myarr
    },

    getGasordinesActives() {
      const globalStore = useGlobalStore()

      return globalStore.gasordines.filter((rec) => rec.active)
    },

    getAutoriByArrayAuthors(authors?: IAuthor[]) {
      // Gestione degli autori
      let authorString = '';
      if (authors && Array.isArray(authors)) {

        // Crea un array di nomi completi
        const fullNames = authors.map(author =>
          `${author.name} ${author.surname}`.trim()
        );

        // Formattazione degli autori
        if (fullNames.length === 1) {
          authorString = fullNames[0];
        } else if (fullNames.length === 2) {
          authorString = `${fullNames[0]} e ${fullNames[1]}`;
        } else if (fullNames.length > 2) {
          const lastAuthor = fullNames.pop();
          authorString = `${fullNames.join(', ')} e ${lastAuthor}`;
        }
      }
      return authorString
    },

    getkeyValStr(chiave: string, valore: any) {
      try {
        return ` ${chiave} = ${valore} `
      } catch (e) {
        return ` ${chiave}`
      }
    },

    replaceKeyWordsByProduct(optcatalogo: IOptCatalogo, myproduct: IProduct, testo: IText, idPage?: string) {
      if (!myproduct || !testo.contenuto) {
        return testo.contenuto;
      }

      const replacements: { [key: string]: any } = {};

      if (testo.contenuto.includes('{autore}')) {
        replacements['{autore}'] = this.getAutoriByArrayAuthors(myproduct.productInfo.authors) || '';
      }

      if (testo.contenuto.includes('{collana}')) {
        replacements['{collana}'] = tools.formatCollane(myproduct.productInfo.idCollana) || '';
      }

      const maxDescriptionLength = testo.maxlength || 680;

      if (testo.contenuto.includes('{descrizione_da_fdv}')) {
        const description = myproduct.productInfo.short_descr || '';
        replacements['{descrizione_da_fdv}'] = description.length > maxDescriptionLength
          ? description.substring(0, description.lastIndexOf(' ', maxDescriptionLength)) + '...'
          : description;
      }

      if (testo.contenuto.includes('{descrizione_estesa_fdv}')) {
        const long_descr = myproduct.productInfo.description || '';
        replacements['{descrizione_estesa_fdv}'] = long_descr.length > maxDescriptionLength
          ? long_descr.substring(0, long_descr.lastIndexOf(' ', maxDescriptionLength)) + '...'
          : long_descr;
      }

      if (testo.contenuto.includes('{descrizione_estesa}')) {
        let addtesto = false;
        const long_descr_macro = myproduct.productInfo.descrizione_completa_macro || '';
        if (long_descr_macro.length > maxDescriptionLength && maxDescriptionLength > 0) {
          addtesto = true;
        }
        const addstrcontinua = '<span class="book-link">👉🏻 <a href="{link_macro}" target="_blank">continua a leggere</a></span>';
        let descrizione_completa_macro = addtesto
          ? long_descr_macro.substring(0, long_descr_macro.lastIndexOf(' ', maxDescriptionLength)) + '...'
          : long_descr_macro;

        if (addtesto) {
          descrizione_completa_macro += addstrcontinua;
        }
        replacements['{descrizione_estesa}'] = descrizione_completa_macro || '';
      }

      if (testo.contenuto.includes('{descrizione_breve_macro}')) {
        const short_descr = myproduct.productInfo.descrizione_breve_macro || '';
        replacements['{descrizione_breve_macro}'] = short_descr.length > maxDescriptionLength && maxDescriptionLength > 0
          ? short_descr.substring(0, short_descr.lastIndexOf(' ', maxDescriptionLength)) + '...'
          : short_descr;
      }

      if (testo.contenuto.includes('{descr_trafiletto_catalogo}') || testo.contenuto.includes('{descrizione_completa_macro}')) {
        const short_descr = myproduct.productInfo.descr_trafiletto_catalogo || '';
        replacements['{descr_trafiletto_catalogo}'] = short_descr.length > maxDescriptionLength && maxDescriptionLength > 0
          ? short_descr.substring(0, short_descr.lastIndexOf(' ', maxDescriptionLength)) + '...'
          : short_descr;
        replacements['{descrizione_completa_macro}'] = replacements['{descr_trafiletto_catalogo}']
      }

      if (testo.contenuto.includes('{prezzo}') || testo.contenuto.includes('{prezzo_scontato}')) {
        const prezzo = tools.arrotonda2Dec(myproduct.arrvariazioni?.[0]?.price) || '';
        const prezzo_scontato = tools.arrotonda2Dec(myproduct.arrvariazioni?.[0]?.sale_price) || '';
        replacements['{prezzo}'] = prezzo;
        replacements['{prezzo_scontato}'] = prezzo_scontato;
      }

      // Additional replacements based on the content
      const keysToCheck = [
        '{titolo}', '{sottotitolo}', '{categoria}', '{sottocategoria}', '{descr_categoria}',
        '{pagine}', '{isbn}', '{misure}', '{edizione}', '{ristampa}', '{argomento}', '{date_pub}', '{date_updated_fromGM}', '{ranking_globale}',
        '{venduti}', '{formato}', '{tipologia}', '{stato}', '{scale}', '{descr_trafiletto_catalogo}',
        '{link_macro}', '{qta}', '{image_link}', '{imagefile}', '{casaeditrice}', '{debug}'
      ];

      for (const key of keysToCheck) {
        if (testo.contenuto.includes(key)) {
          switch (key) {
            case '{titolo}':
              replacements[key] = myproduct.productInfo.name || '';
              break;
            case '{sottotitolo}':
              replacements[key] = myproduct.productInfo.sottotitolo || '';
              break;
            case '{sottocategoria}':
              replacements[key] = myproduct.productInfo.subcatprods && myproduct.productInfo.subcatprods.length > 0 ? myproduct.productInfo.subcatprods[0].name! : '';
              break;
            case '{descr_categoria}':
              replacements[key] = myproduct.productInfo.catprods && myproduct.productInfo.catprods.length > 0 ? this.getCatProdDescrStrByIdCatProd(myproduct.productInfo.catprods![0].name) : '';
              break;
            case '{pagine}':
              replacements[key] = myproduct.arrvariazioni?.[0]?.pagine || '';
              break;
            case '{isbn}':
              replacements[key] = myproduct.productInfo.code || '';
              break;
            case '{misure}':
              replacements[key] = myproduct.arrvariazioni?.[0]?.misure || '';
              break;
            case '{casaeditrice}':
              replacements[key] = this.getCasaEditriceByIdPublisher(myproduct.productInfo.idPublisher)
              break;
            case '{edizione}':
              replacements[key] = myproduct.arrvariazioni?.[0]?.edizione || '';
              break;
            case '{ristampa}':
              replacements[key] = myproduct.arrvariazioni?.[0]?.ristampa || '';
              break;
            case '{argomento}':
              replacements[key] = this.getCatProdsStrByCatProds(myproduct.productInfo.catprods!) || '';
              break;
            case '{date_pub}':
              replacements[key] = tools.getstrDateShort(myproduct.productInfo.date_pub) || '';
              break;
            case '{date_updated_fromGM}':
              replacements[key] = tools.getstrDateShort(myproduct.productInfo.date_updated_fromGM) || '';
              break;
            case '{ranking_globale}':
              replacements[key] = myproduct.productInfo.rank3M! || '0';
              break;
            case '{venduti}':
              replacements[key] = myproduct.productInfo.totVen! || '0';
              break;
            case '{formato}':
              replacements[key] = this.getDescrByIdTipoFormato(myproduct.arrvariazioni?.[0]?.idTipoFormato || 0)
              break;
            case '{tipologia}':
              replacements[key] = this.getDescrByIdTipologia(myproduct.arrvariazioni?.[0]?.idTipologia || 0);
              break;
            case '{stato}':
              replacements[key] = this.getDescrStatiProdottoByIdStatoProdotto(myproduct.productInfo.idStatoProdotto || '');
              break;
            case '{scale}':
              replacements[key] = optcatalogo.printable ? optcatalogo.areadistampa?.scale : '1';
              break;
            case '{link_macro}':
              replacements[key] = myproduct.productInfo.link_macro || '';
              break;
            case '{qta}':
              replacements[key] = myproduct.arrvariazioni?.[0]?.quantita || '';
              break;
            case '{image_link}':
              replacements[key] = myproduct.productInfo.image_link || '';
              break;
            case '{imagefile}':
              replacements[key] = myproduct.productInfo.imagefile || '';
              break;
            case '{debug}':
              const date_pub = replacements['{date_pub}'] || '';
              const fatLast6M = myproduct.productInfo.fatLast6M! || 0;
              const linkvenduti = `<a href="http://vps-88271abb.vps.ovh.net/apimacro/public/view-ordini-by-idarticolo/${myproduct.productInfo.sku}" target="_blank">${myproduct.productInfo.totVen!}</a>`;
              const vLast3M = myproduct.productInfo.vLast3M! || 0;
              const vLast6M = myproduct.productInfo.vLast6M! || 0;
              const linkfatturati = `<a href="http://vps-88271abb.vps.ovh.net/apimacro/public/view-fatturati-by-idarticolo/${myproduct.productInfo.sku}" target="_blank">${myproduct.productInfo.totFat! || 0}</a>`;
              const fatLast3M = myproduct.productInfo.fatLast3M! || 0;

              replacements[key] = this.getkeyValStr('Pub:', date_pub) +
                this.getkeyValStr('fat6M', fatLast6M) +
                this.getkeyValStr('Ven:', linkvenduti) +
                this.getkeyValStr('v3M', vLast3M) +
                this.getkeyValStr('v6M', vLast6M) +
                this.getkeyValStr('Fatt:', linkfatturati) +
                this.getkeyValStr('fat3M', fatLast3M);
              break;
          }
        }
      }

      // Esegue le sostituzioni
      let result = testo.contenuto;
      for (const [key, value] of Object.entries(replacements)) {
        result = result.replace(new RegExp(key, 'g'), value);
      }

      return result.trim();
    },

    getSubCatStrByProduct(myproductInfo: IProductInfo): string {
      return this.getSubCatProdsStrBySubCatProds(myproductInfo.idSubCatProds || [])
    },

    getListProductBySumQuantity(idGasordine: string): ISingleProductOrdered[] {

      const arrprod = this.orders.filter((rec: IOrderCart) => {
        if (idGasordine && !rec.items?.some(item => item.order && item.order.idGasordine === idGasordine)) {
          return false; // Skip records not matching gasordine condition
        }
        return true;
      });

      const productMap = new Map<string, ISingleProductOrdered>();

      arrprod.forEach((rec: IOrderCart) => {
        rec.items?.forEach(item => {
          if (item.order && item.order.idGasordine === idGasordine) {
            const productId: string = item.order.idProduct!;
            const qtyparz = item.order.quantity + item.order.quantitypreordered
            if (productMap.has(productId)) {
              const existingProduct: ISingleProductOrdered = productMap.get(productId)!
              existingProduct.qty += qtyparz
              existingProduct.subtotalPrice += item.order.price * qtyparz
              existingProduct.subtotalPrice = Number((existingProduct.subtotalPrice).toFixed(2))
            } else {

              const sottocategoria = item.order.product?.productInfo?.subcatprods && item.order.product?.productInfo?.subcatprods.length > 0 ? item.order.product?.productInfo?.subcatprods[0].name : ''
              productMap.set(productId, {
                subCat: sottocategoria,
                strSubCatProds: this.getSubCatProdsStrBySubCatProds(item.order.product?.productInfo?.idSubCatProds),
                index: productMap.size + 1,
                idProduct: productId,
                code: item.order.product?.productInfo.code,
                codice_interno: item.order.product?.productInfo?.codice ?? '',
                qty: qtyparz,
                singlePrice: item.order.price,
                subtotalPrice: Number((item.order.price * qtyparz).toFixed(2)),
                productName: item.order.product?.productInfo?.name ?? '',
              });
            }
          }
        });
      });

      return Array.from(productMap.values());

    },

    getSchedeOpt(arrschede: ISchedaSingola[], tag?: string): any[] {

      let arr: any = []

      const globalStore = useGlobalStore()

      arr.push({ label: '[Nessuna]', value: '' })

      if (arrschede) {
        arrschede.forEach((recscheda: ISchedaSingola) => {
          let pagename = ''
          if (recscheda.scheda) {
            if (recscheda.idPageOrig) {
              const page = globalStore.getPageById(recscheda.idPageOrig)
              // const page = this.mypage?.find((page) => (`${page._id}`) === recscheda.idPageOrig)
              pagename = page ? page.title! : ''
            }
            if (pagename)
              pagename = '[Pag: ' + pagename + '] '

            const mylabel = pagename + (recscheda.scheda ? recscheda.scheda!.name : '')
            if (!tag || mylabel.startsWith(tag)) {
              arr.push({ label: mylabel, value: recscheda.scheda!._id })
            }
          }
        });
      }

      return arr

    },

    addNewScheda(catalogo: IOptCatalogo) {

      let maxorder = 0
      catalogo!.arrSchede?.forEach(scheda => {
        if (scheda?.order > maxorder) {
          maxorder = scheda.order
        }
      })


      let testodef: IText = {}
      testodef = tools.resetIText(testodef)

      const defaultDimensioniPag = tools.resetRecIDimensioni(null)
      defaultDimensioniPag.size = {
        width: '800px',
        height: '600px',
      }
      defaultDimensioniPag.margini = {
        top: '12px',
        bottom: '0px',
        left: '0px',
        right: '0px',
      }
      defaultDimensioniPag.padding = {
        top: '0px',
        bottom: '0px',
        left: '0px',
        right: '0px',
      }

      const defaultDimensioniRiga = tools.resetRecIDimensioni(null)

      defaultDimensioniRiga.size = {
        width: '800px',
        height: '300px',
      }
      defaultDimensioniRiga.margini = {
        top: '40px',
        bottom: '0px',
        left: '0px',
        right: '0px',
      }
      defaultDimensioniRiga.padding = {
        top: '0px',
        bottom: '0px',
        left: '0px',
        right: '0px',
      }

      const defaultSchedaProdotto = tools.resetRecIDimensioni(null)

      defaultSchedaProdotto.size = {
        width: '360px',
        height: '230px',
      }

      defaultSchedaProdotto.margini = {
        top: '0px',
        bottom: '0px',
        left: '0px',
        right: '0px',
      }

      defaultSchedaProdotto.padding = {
        top: '0px',
        bottom: '0px',
        left: '0px',
        right: '0px',
      }

      const dimensioni: IElementiScheda = {
        pagina: { dimensioni: defaultDimensioniPag, testo_down: testodef, testo_up: testodef, testo_title: testodef },
        riga: defaultDimensioniRiga,
        scheda_prodotto: defaultSchedaProdotto,
        immagine_prodotto: {
          size: {
            width: '150px',
            height: '235px',
          },
          margini: {
            top: '0px',
            bottom: '0px',
            left: '0px',
            right: '0px',
          },
          padding: {
            top: '0px',
            bottom: '0px',
            left: '0px',
            right: '0px',
          },
        },
      }

      const newscheda: IMyScheda = {
        _id: objectId(),
        idapp: tools.appid()!,
        isTemplate: false,
        isPagIntro: false,
        show_separatore: true,
        name: 'Scheda Nuova',
        dimensioni,
        numschede_perRiga: 2,
        numschede_perCol: 2,
        testo_right_attaccato: {
          contenuto: '',
          maxlength: 0,
          font: {
            posiz_text: costanti.POSIZ_TESTO.A_DESTRA,
          },
        },
        testo_right: {
          contenuto: '',
          maxlength: 0,
          font: {
            posiz_text: costanti.POSIZ_TESTO.A_DESTRA,
          },
        },
        testo_bottom: {
          contenuto: '',
          maxlength: 0,
          font: {
            posiz_text: costanti.POSIZ_TESTO.IN_BASSO,
          }
        },
        barcode: {
          show: false,
          format: '',
          size: {
            width: '2',
            height: '100',
          },
          font: {
            name: 'monospace',
            size: '16px',
          }
        },
        productTypes: [],
        excludeproductTypes: [],
        idTipologie: [],
        editore: [],
        argomenti: [],
        author: '',
        sort_field: '',
        sort_dir: 0,
        arrProdottiSpeciali: [],
        etichette: {
          novita: {
            show: false,
            months: 6,
          },
          bestseller: {
            show: false,
            quantiFattRaggiunti: 50
          }
        }
      }

      if (!catalogo!.arrSchede)
        catalogo!.arrSchede = []

      catalogo!.arrSchede.push(
        {
          _id: objectId(),
          scheda: newscheda,
          order: maxorder + 10,
          numPagineMax: 0,
        }
      )

    },


    getPathByPage(idpag: string) {

      let linkpage = ''

      const globalStore = useGlobalStore()

      if (idpag) {
        const mypage = globalStore.getPageById(idpag)
        if (mypage)
          linkpage = mypage.path!
      }

      return linkpage

    },


  },

})