''openUploadUI()''

openUploadUI() apre un'interfaccia grafica per il caricamento di file che invia i file selezionati al server, dove vengono elaborati da uno script Groovy specificato dallo sviluppatore.

L'UI offre:

• Area drag & drop con selezione via file picker dell'OS
• Lista dei file selezionati con possibilità di rimozione singola
• Validazione client-side su estensione e dimensione totale
• Upload automatico oppure su click di un pulsante “Carica”
• Apertura in FloatingPane (default) oppure in un contenitore esistente
• Notifiche via dialog, MessageToaster o callback personalizzato

UI minimale, nessun parametro:

UI che mostra la selezione corrente

Notifica standard si avvenuto caricamento in base al messaggio ritornato dal groovy

openUploadUI(scriptName, options)

Esempio di validazione fallita

Esempio con utilizzo esteso dei parametri:

Lo script Groovy riceve nel Binding le seguenti variabili:

Il controller legge esclusivamente il Map restituito dallo script per determinare successo e messaggio:

Lo script può aggiungere dati extra alla risposta tramite jsonServerResponse.addResponseObject(“key”, value), accessibili nel callback JS come resp.responseHashMap.key.

<note warning> Attenzione: se lo script restituisce null o un tipo non-Map, il controller lancia una RuntimeException e l'upload viene considerato fallito. </note>

// Script in: mypackage/ImportScript.groovy  →  scriptName: "mypackage.ImportScript"
 
def result = [:]
def success = false
def message = null
 
try {
    // Variabili disponibili nel binding:
    //   file           {MultipartFile}   – primo file caricato (o null se assente)
    //   files          {MultipartFile[]} – tutti i file caricati
    //   parametersMap  {Map}             – parametri extra inviati dal JS (alias: parameters)
    //   <chiave>       {Object}          – ogni entry di parametersMap è disponibile individualmente
    //   gw_activeUser, gw_activeGroup, gw_projectName, gw_projectPath, ...
    //   services, log, applicationContext, environment, ...
 
    def parameterValue = parametersMap.parameter_name
 
    // ... elaborazione ...
    byte[] bytes = file.getBytes()
    // ...
 
    success = true
    message = 'file(s) correctly processed'
 
} catch (Exception e) {
    log.error(e.getMessage(), e)
    success = false
    message = 'ko'
} finally {
    result.success = success
    result.message = message
}
 
return result

// Apre il FloatingPane default 600×600.
// L'utente seleziona un file e clicca "Carica".
// Al successo compare showOkDialog con il messaggio del server.
 
openUploadUI('mypackage.SimpleImport');

// Mostra un'area di testo con istruzioni sopra la drop zone.
 
openUploadUI('mypackage.SimpleImport', {
    instructions: 'Carica il file di importazione in formato Excel.<br>' +
                  'Il file non deve superare le 1000 righe.'
});

// L'upload parte automaticamente non appena il file viene selezionato/trascinato.
// Il pulsante "Carica" non compare.
 
openUploadUI('mypackage.QuickProcess', {
    autoupload: true
});

// Permette la selezione e il caricamento di più file in una sola chiamata.
// Il server riceve files[] con tutti i file.
 
openUploadUI('mypackage.BatchImport', {
    multiple: true
});

// Impedisce l'upload se la dimensione totale supera 5 MB.
// Il bottone "Carica" viene disabilitato e compare un messaggio localizzato.
 
openUploadUI('mypackage.DocumentUpload', {
    maxUploadSizeMB: 5
});

// Accetta solo file PDF e Word. La restrizione vale sia per il drag&drop
// sia per il file picker dell'OS (attributo accept).
 
openUploadUI('mypackage.DocumentImport', {
    allowedExtensions: ['pdf', 'doc', 'docx']
});

// L'UI viene inserita nel widget Dojo con id "myContentPane"
// invece di aprire un FloatingPane.
 
openUploadUI('mypackage.EmbeddedUpload', {
    containerRef: 'myContentPane'
});

// L'UI viene inserita direttamente in un nodo DOM.
 
var container = document.getElementById('uploadArea');
openUploadUI('mypackage.EmbeddedUpload', {
    containerRef: container
});

// Il FloatingPane viene aperto con dimensioni personalizzate.
 
openUploadUI('mypackage.LargeImport', {
    dimensions: { w: 800, h: 500 }
});

// Il FloatingPane viene aperto in modalità modale:
// l'utente non può interagire con il resto della pagina finché non chiude il pannello.
 
openUploadUI('mypackage.CriticalImport', {
    modal: true
});

// La posizione e le dimensioni del FloatingPane vengono salvate in localStorage.
// Alla successiva apertura il pannello si riposiziona dove era stato lasciato.
 
openUploadUI('mypackage.RecurringImport', {
    useCookie: true
});

// Il messaggio di successo appare nel MessageToaster invece che in un dialog.
// Utile quando si vuole una notifica non bloccante.
 
openUploadUI('mypackage.SilentImport', {
    useToaster: true
});

// Passa parametri aggiuntivi al Groovy script.
// Nel binding saranno disponibili come:
//   parametersMap["targetTable"], parameters["targetTable"]  → "anagrafica"
//   targetTable  → "anagrafica"   (variabile individuale)
//   overwrite    → true           (variabile individuale)
 
openUploadUI('mypackage.TableImport', {
    parameters: {
        targetTable: 'anagrafica',
        overwrite:   true,
        userId:      42
    }
});

Lato Groovy:

log.info("Importazione in tabella: ${targetTable}, overwrite: ${overwrite}")
// oppure
log.info("Tabella: ${parametersMap.targetTable}")

// Callback personalizzato al successo: riceve il JsonServerResponse completo.
// Il FloatingPane si chiude ugualmente dopo il callback.
 
openUploadUI('mypackage.ImportWithResult', {
    callback: function(resp) {
        var importedCount = resp.responseHashMap.result.importedCount;
        showOkDialog({ message: 'Importati ' + importedCount + ' record.' });
        // aggiorna la datagrid aperta
        refreshDatagrid();
    }
});

// Gestione personalizzata degli errori di rete o di script.
 
openUploadUI('mypackage.CriticalImport', {
    errorCallback: function(err) {
        console.error('Upload fallito:', err.description);
        showErrorDialog('Errore durante il caricamento: ' + err.description);
        // logica di ripristino personalizzata
        rollbackLocalState();
    }
});

openUploadUI('reportistica.ImportazioneExcel', {
 
    // Istruzioni per l'utente
    instructions: 'Carica il file Excel con i dati da importare.<br>' +
                  'Sono ammessi solo file .xlsx e .xls, max 10 MB.',
 
    // Selezione e validazione
    multiple:          false,
    allowedExtensions: ['xlsx', 'xls'],
    maxUploadSizeMB:   10,
    autoupload:        false,
 
    // Posizionamento: FloatingPane personalizzato
    containerRef:      null,
    dimensions:        { w: 750, h: 550 },
    modal:             true,
    useCookie:         false,
 
    // Parametri extra per il Groovy
    parameters: {
        projectCode:  gwProjectName,
        targetEntity: 'Dipendenti',
        dryRun:       false
    },
 
    // Notifica di successo non bloccante
    useToaster: false,
 
    // Callback di successo personalizzato
    callback: function(resp) {
        var result = resp.responseHashMap.result;
        showOkDialog({
            message: 'Importazione completata.<br>' +
                     'Record inseriti: <b>' + result.insertedRows + '</b><br>' +
                     'Errori: <b>' + result.errorRows + '</b>'
        });
        topic.publish('myApp/dataChanged', { entity: 'Dipendenti' });
    },
 
    // Gestione errori personalizzata
    errorCallback: function(err) {
        showErrorDialog('Importazione fallita: ' + err.description);
    }
});

L'utente carica un file .xlsx contenente anagrafiche. Il Groovy legge il file riga per riga (con Apache POI, già disponibile tramite i servizi nel binding) e inserisce o aggiorna i record nel database.

openUploadUI('import.AnagraficaImport', {
    instructions:      'File Excel con le colonne: Cognome, Nome, CF, Email.',
    allowedExtensions: ['xlsx', 'xls'],
    maxUploadSizeMB:   2,
    useToaster:        true,
    callback: function(resp) {
        datagridAnagrafica.refresh();
    }
});

L'UI viene visualizzata all'interno di un pannello del dettaglio scheda già aperto, senza aprire un nuovo FloatingPane. Al successo, la lista allegati viene aggiornata.

openUploadUI('allegati.CaricaAllegato', {
    containerRef:      dijit.registry.byId('attachmentsTab'),
    allowedExtensions: ['pdf', 'jpg', 'png', 'docx'],
    maxUploadSizeMB:   20,
    parameters:        { itemId: currentItemId, className: 'Pratica' },
    callback: function(resp) {
        refreshAttachmentsList();
    }
});

L'utente trascina più immagini contemporaneamente. L'upload parte senza necessità di cliccare alcun pulsante. Il Groovy ridimensiona e archivia le immagini.

openUploadUI('media.ImageUploader', {
    instructions:      'Trascina le immagini o usa il pulsante Sfoglia. Formati ammessi: JPG, PNG, WEBP.',
    multiple:          true,
    autoupload:        true,
    allowedExtensions: ['jpg', 'jpeg', 'png', 'webp'],
    maxUploadSizeMB:   50,
    dimensions:        { w: 700, h: 480 },
    useToaster:        true
});

Un amministratore carica un file di configurazione. Il Groovy valida il JSON, applica la configurazione e restituisce un report dettagliato. L'UI si apre in modalità modale per impedire operazioni concorrenti.

openUploadUI('admin.ConfigImport', {
    instructions:      "Carica il file di configurazione esportato. Attenzione: l'operazione è irreversibile.",
    allowedExtensions: ['json'],
    maxUploadSizeMB:   1,
    modal:             true,
    parameters:        { environment: 'production', validateOnly: false },
    callback: function(resp) {
        var report = resp.responseHashMap.result;
        showOkDialog({
            message: 'Configurazione applicata.<br>Voci aggiornate: ' + report.updatedKeys
        });
    },
    errorCallback: function(err) {
        showErrorDialog('Configurazione non valida: ' + err.description);
    }
});

L'utente rimpiazza un documento esistente. Il Groovy archivia la versione precedente e salva quella nuova, restituendo metadati sulla versione creata.

openUploadUI('documenti.SostituisciDocumento', {
    allowedExtensions: ['pdf'],
    maxUploadSizeMB:   30,
    useCookie:         true,
    parameters: {
        documentId:  currentDocumentId,
        keepHistory: true
    },
    callback: function(resp) {
        var meta = resp.responseHashMap.result;
        messageToaster.setContent(
            'Versione ' + meta.versionNumber + ' salvata.', 'message'
        );
        messageToaster.show();
        reloadDocumentDetail(currentDocumentId);
    }
});

L'ufficio carica più file CSV (uno per categoria) in un'unica operazione. Il Groovy li elabora in sequenza e produce un report consolidato.

openUploadUI('batch.MultiCSVImport', {
    instructions:      'Seleziona tutti i file CSV da importare in una volta sola.',
    multiple:          true,
    allowedExtensions: ['csv'],
    maxUploadSizeMB:   25,
    dimensions:        { w: 700, h: 500 },
    parameters:        { separator: ';', encoding: 'UTF-8' },
    callback: function(resp) {
        var r = resp.responseHashMap.result;
        showOkDialog({
            message: 'Elaborati ' + r.filesProcessed + ' file.<br>' +
                     'Righe importate: ' + r.totalRows + '<br>' +
                     'Errori: ' + r.totalErrors
        });
        refreshReportDashboard();
    }
});

Prima di un import definitivo, l'utente può eseguire una validazione “dry run” che non scrive sul database ma restituisce l'elenco degli errori trovati.

function apriValidazione(isDryRun) {
    openUploadUI('import.ValidatedImport', {
        instructions: isDryRun
            ? 'Modalità VERIFICA: nessun dato verrà scritto nel database.'
            : 'Modalità IMPORTAZIONE: i dati verranno scritti nel database.',
        allowedExtensions: ['xlsx'],
        maxUploadSizeMB:   5,
        parameters: {
            dryRun:      isDryRun,
            targetTable: 'Contratti'
        },
        callback: function(resp) {
            var r = resp.responseHashMap.result;
            if (isDryRun) {
                showOkDialog({
                    message: 'Verifica completata.<br>' +
                             'Righe valide: ' + r.validRows + '<br>' +
                             'Righe con errori: ' + r.errorRows
                });
            } else {
                messageToaster.setContent('Importati ' + r.insertedRows + ' record.', 'message');
                messageToaster.show();
            }
        }
    });
}
 
// Uso:
apriValidazione(true);   // solo verifica
apriValidazione(false);  // importazione reale

Il controller restituisce sempre un JsonServerResponse in formato JSON:

{
  "success": true,
  "description": "Operazione eseguita con successo",
  "errorDetailList": [],
  "responseHashMap": {
    "result": { ... }
  }
}

Il campo result contiene il valore di ritorno dello script Groovy.

La dimensione massima lato server è configurata in dispatcher-servlet.xml tramite CommonsMultipartResolver. Il parametro maxUploadSizeMB in openUploadUI è una validazione client-side che si aggiunge (non sostituisce) al limite server.

Quando si usa containerRef, l'UI occupa il 100% dello spazio disponibile nel contenitore (width: 100%; height: 100%). Il contenitore deve avere una dimensione definita (es. height esplicita o essere un ContentPane Dojo con layout calcolato).

La funzione dipende dalle seguenti variabili globali definite dalla pagina JSP:

Issue di riferimento: #1824
File sorgente JS: gw-commons-web/…/debug/js/gwCommons.js
Controller: gw-webclient/…/controller/commons/UploadToGroovyController.java
Endpoint: POST /{projectName}/uploadToGroovy