Composables

useImportStatus, useImportHistory, useExportTemplates

Polling import asincrono, storico importazioni e gestione template di export.

useImportStatus

Wrapper su usePolling specifico per import. Effettua il polling di GET /import/status/:id, normalizza i valori stato italiani del backend (es. completato, errore, in_corso) nel tipo ImportStato interno (inglese: completed, error, importing).

Inizializzazione

import { useImportStatus, ImportExportApi } from '@pzeta/vue-importexport'

// Fuori da ImportWizard/ExportDialog il client si passa esplicitamente (useApi() lì lancia)
const api = new ImportExportApi(baseUrl)
const { progresso, isPolling, errore, startPolling, stopPolling, reset } = useImportStatus(api)

Stato reattivo

Proprietà	Tipo	Descrizione
`progresso`	`Ref<ImportProgresso \| null>`	Stato corrente dal server (con `stato` normalizzato)
`isPolling`	`Ref<boolean>`	Polling attivo
`errore`	`Ref<string \| null>`	Errore di rete o stato `error` ricevuto

Metodi

Metodo	Descrizione
`startPolling(importId)`	Avvia il polling per un dato `importId`
`stopPolling()`	Ferma il polling
`reset()`	Stop + azzera `progresso` e `errore`

Mappatura stati server → interno

{
  completato:    'completed',
  errore:        'error',
  in_corso:      'importing',
  importazione: 'importing',
  caricamento:   'uploading',
}

Esempio

const status = useImportStatus(api)

const result = await api.executeImport(sessionId, mappings)
if (result.stato !== 'completato') {
  status.startPolling(result.importId)
}

watch(() => status.progresso.value?.stato, (s) => {
  if (s === 'completed') showToast('Import completato!')
})

useImportHistory

Carica lo storico importazioni filtrabile per risorsa. Singolo metodo loadHistory(), niente polling.

Inizializzazione

import { useImportHistory, ImportExportApi } from '@pzeta/vue-importexport'

const api = new ImportExportApi(baseUrl)
const { items, loading, errore, loadHistory } = useImportHistory('anagrafica', api)
// senza filtro: useImportHistory(undefined, api)
// senza client usa useApi(): funziona solo dentro ImportWizard / ExportDialog

Parametri

Parametro	Tipo	Default	Descrizione
`risorsa`	`string`	`undefined`	Filtro server-side per risorsa
`apiOverride`	`ImportExportApi`	`useApi()`	Istanza API custom

Stato reattivo

Proprietà	Tipo	Descrizione
`items`	`Ref<ImportHistoryItem[]>`	Storico caricato
`loading`	`Ref<boolean>`	Caricamento in corso
`errore`	`Ref<string \| null>`	Errore caricamento

Tipo `ImportHistoryItem`

interface ImportHistoryItem {
  importId: string
  risorsa: string
  nomeFile: string
  formato: FileFormato
  stato: 'completato' | 'parziale' | 'errore'
  righeImportate: number
  righeScartate: number
  dataEsecuzione: string
  esecutore: string
}

Esempio

const history = useImportHistory('contratto')
onMounted(history.loadHistory)

useExportTemplates

Gestione CRUD dei modelli di esportazione (ModelloExport). Usato internamente da useExport.templateManager.

Inizializzazione

import { useExportTemplates, ImportExportApi } from '@pzeta/vue-importexport'

const api = new ImportExportApi(baseUrl)   // useExportTemplates vuole sempre il client
const {
  templates, selectedTemplate, loading, errore,
  loadTemplates, saveTemplate, updateTemplate, deleteTemplate, selectTemplate,
} = useExportTemplates(api)

Stato reattivo

Proprietà	Tipo	Descrizione
`templates`	`Ref<ModelloExport[]>`	Lista template
`selectedTemplate`	`Ref<ModelloExport \| null>`	Template selezionato
`loading`	`Ref<boolean>`	Operazione in corso
`errore`	`Ref<string \| null>`	Messaggio per l'utente dell'ultimo errore (es. «Impossibile salvare il modello. Controlla nome e descrizione.»); il dettaglio tecnico va nei log

Metodi

Metodo	Descrizione	Endpoint
`loadTemplates(risorsa?)`	Carica template della risorsa	`GET /export/templates?risorsa=…`
`saveTemplate(template)`	Crea nuovo template	`POST /export/templates`
`updateTemplate(id, updates)`	Aggiorna template esistente	`PUT /export/templates/:id`
`deleteTemplate(id)`	Elimina template (rimuove anche da `templates.value`)	`DELETE /export/templates/:id`
`selectTemplate(template)`	Imposta `selectedTemplate.value`	—

Esempio

const tm = useExportTemplates(api)
await tm.loadTemplates('anagrafica')

const created = await tm.saveTemplate({
  nome: 'Export clienti standard',
  descrizione: 'Solo clienti attivi con email',
  risorsa: 'anagrafica',
  formato: 'xlsx',
  campi: ['nome', 'cognome', 'email'],
  filtri: { attivo: true },
  condiviso: true,
})

if (created) {
  tm.selectTemplate(created)
}

Note

Dalla 0.8.0 errore.value è scritto per l'utente: un'apertura per l'operazione («Impossibile caricare i modelli.», «Impossibile salvare il modello.», «Impossibile eliminare il modello.») e il messaggio del servizio o un testo per stato HTTP. Prima era Salvataggio template fallito per <nome>: Errore API: …. Tabella dei casi: ExportDialog › Modelli
saveTemplate restituisce ModelloExport | null (null in caso di errore — il messaggio è in errore.value); ExportDialog lo usa per tenere aperto il salvataggio finché non riesce
Dalla 1.1.13 di node-excel-export solo chi ha admin/superadmin in X-User-Roles crea o modifica modelli condivisi (condiviso: true) o con rawquery: per gli altri il servizio risponde 403, che arriva in errore.value
deleteTemplate restituisce boolean; updateTemplate restituisce ModelloExport | null
Allo deleteTemplate riuscito, se selectedTemplate.value.id === id, la selezione viene azzerata
Il backend (node-excel-export) usa internamente l'entità MsTemplate; la libreria fa il mapping bidirezionale tramite mapMsTemplateToModello

Template di esportazione

TemplateManager e TemplateSaveDialog.

useExport

Composable principale per generare ed eseguire un export.