Skip to content

Sharepoint - Applicare il trascinamento dei documenti per applicare i metadati

I nostri migliori programmatori hanno esaurito le loro scorte di caffè, cercando continuamente la risposta, finché Julian non ha trovato la soluzione su GitLab, quindi oggi la condivide con noi.

Soluzione:

Mi sono imbattuto in questa soluzione durante la ricerca e ho pensato di aggiungere i miei pensieri. Anch'io stavo cercando un modo per affrontare questo problema.

Il DragDrop.js in Layout ha una funzione chiamata UploadProgressFunc che è essenzialmente una dichiarazione di commutazione. Una delle opzioni di questo interruttore è uploaded. Questa è la funzione a cui attingere se si desidera gestire la situazione in modo diverso.

function UploadProgressFunc(percentDone, timeElapsed, state) {
    state.percentDone = percentDone;
    var messageType = ProgressMessage.EMPTY;

    switch (state.status) {
        case 1:
            messageType = ProgressMessage.VALIDATION;
            break;
        case 3:
            messageType = ProgressMessage.UPLOADING;
            break;
        case 4:
            messageType = ProgressMessage.UPLOADED;
            MyNewFunction();
            break;
        case 5:
            messageType = ProgressMessage.CANCELLED;
            break;
    }
    UpdateProgressBar(messageType, state);
}

Ho creato un file js separato chiamato DragDrop.Extended.jsche contiene una copia del file UploadProgressFunc che chiama semplicemente una nuova funzione dopo aver impostato il messageType su case 4.

Questo per utilizzare il comportamento di Javascripts che sovrascrive le funzioni esistenti con quella nuova quando viene caricato un duplicato. In questo modo non devo modificare alcun file OOTB. Posso semplicemente eseguire questo frammento di js nella mia pagina principale.

window.onload = function(){
        setTimeout( function(){
            if(typeof UploadProgressFunc != 'undefined'){
                $.getScript("path_to_my_custom_js_file/DragDrop.Extended.js");
            }
        }, 4000);
 };

Ora, essendo nella pagina principale, viene eseguito per ogni pagina. Spero di trovare una soluzione migliore. Il codice controlla se il file dragdrop.js è stato caricato, verificando se la funzione è indefinita. Se è stato caricato, carica anche il mio file per sovrascrivere la funzione.

La nuova funzione utilizzata attualmente gestisce solo un file alla volta; al momento sto lavorando per farle gestire più file. La nuova funzione utilizza JSOM per ottenere informazioni sul file caricato. Quindi crea una chiamata all'elenco per recuperare l'ID del file caricato. Questo è necessario perché non viene mai riportato l'ID nel contesto durante il caricamento.

Con l'ID e i dettagli disponibili nel contesto, sono in grado di costruire l'URL di EditForm per quell'elemento. Poi passo l'URL di EditForm in una finestra di dialogo SP.

var options = SP.UI.$create_DialogOptions();
options.title = "Add File Metadata";
options.url = editFormAddress;
options.autoSize = true;

SP.UI.ModalDialog.showModalDialog(options);

Con tutto questo, dopo che l'utente trascina un elemento nella libreria dei documenti, appare una finestra di dialogo per aggiungere i metadati. Per ora è un punto di partenza. Attualmente sto cercando di farlo funzionare per più file e di trovare una soluzione più elegante per caricare lo script della funzione di sovrascrittura.

//edit

Per ottenere gli ID dei file caricati ho usato JSOM e ho interrogato la libreria dei documenti con una query CAML. È possibile ottenere il nome della libreria dal contesto e il nome utente corrente. Con questi dati ho cercato i file caricati dall'utente negli ultimi minuti e ho costruito un array JS di url di modifica.

Ho poi caricato dei pulsanti personalizzati nella modale usando javascript, che scorrevano avanti e indietro attraverso l'array di URL di modifica costruito con i risultati della query. Ho dovuto sovrascrivere anche la funzione di invio, altrimenti chiudeva la finestra dopo averne salvato uno. Ho rimosso gli URL di modifica dall'array dopo ogni salvataggio.

Non lavoro più su quel progetto, quindi mi scuso per la mancanza di esempi di codice nella modifica.

Ecco una versione estesa e corretta del codice trovato nelle altre risposte.

Le caratteristiche sono:

  • Aprire il modulo di modifica dopo il trascinamento
  • Aprire il modulo di modifica per multiplo file

(function (_window) {
    var maxTimeForReplaceUploadProgressFunc = 10000;
    function replaceUploadProgressFunc() {
        if (typeof _window.UploadProgressFunc != 'undefined') {
            _window.Base_UploadProgressFunc = _window.UploadProgressFunc;
            _window.UploadProgressFunc = Custom_UploadProgressFunc;
            console.log('replaced dialog');
        } else if (maxTimeForReplaceUploadProgressFunc > 0) {
            maxTimeForReplaceUploadProgressFunc -= 100;
            setTimeout(replaceUploadProgressFunc, 100);
        }
    }
    setTimeout(replaceUploadProgressFunc, 100);

    function Custom_UploadProgressFunc(percentDone, timeElapsed, state) {
        _window.Base_UploadProgressFunc(percentDone, timeElapsed, state);
        var messageType = ProgressMessage.EMPTY;
        switch (state.status) {
            case 1:
                messageType = ProgressMessage.VALIDATION;
                break;
            case 3:
                messageType = ProgressMessage.UPLOADING;
                break;
            case 4:
                messageType = ProgressMessage.UPLOADED;
                OpenEditFormForLastItem(state);
                break;
            case 5:
                messageType = ProgressMessage.CANCELLED;
                break;
        }

        function OpenEditFormForLastItem(state) {
            var caml = '';
            caml += "";
            caml += "";
            caml += "";

            if (state.files.length > 1) {
                caml += "";
                caml += "";
                caml += "";
            } else {
                caml += "";
                caml += "";
            }

            state.files.forEach(function (file) {
                //only succesfull uploaded files that arent overwrites
                console.log(file);
                if (file.status === 5 /*&& !file.overwrite*/) {
                    caml += "" + file.fileName + "";
                }
            }, this);

            if (state.files.length > 1) {
                caml += "";
                caml += "";
            } else {
                caml += "";
            }

            caml += "";
            caml += "";
            caml += "";
            caml += "";
            caml += "500";
            caml += "";
            console.log(caml);

            var cntxt = SP.ClientContext.get_current();
            var web = cntxt.get_web();
            var list = web.get_lists().getByTitle(window.ctx.ListTitle);
            var query = new SP.CamlQuery();
            query.set_viewXml(caml);
            var items = list.getItems(query);
            cntxt.load(list, 'DefaultEditFormUrl');
            cntxt.load(items);
            cntxt.executeQueryAsync(function () {
                var listEnumerator = items.getEnumerator();
                function openEditForItem() {
                    if (listEnumerator.moveNext()) {
                        var item = listEnumerator.get_current();
                        var id = item.get_id();

                        var options = SP.UI.$create_DialogOptions();
                        options.title = "Add File Metadata";
                        options.url = list.get_defaultEditFormUrl() + '?ID=' + id;
                        options.autoSize = true;
                        options.dialogReturnValueCallback = openEditForItem;
                        SP.UI.ModalDialog.showModalDialog(options);
                    } else {
                        location.reload();
                    }
                }
                openEditForItem();
            }, function (error, args) {
                    console.log("failed to get new uploaded items");
                    console.log(error);
                    console.log(args);
                });
        }
    }
})(window);

Si tratta di un problema che si presenta da molto tempo: il caricamento di più file presenta lo stesso problema, in quanto non è possibile applicare i metadati agli elementi quando se ne carica più di uno alla volta. La soluzione consiste nel rendere obbligatori i campi dei metadati desiderati. In questo modo si obbliga il caricatore a mantenere il controllo dei file fino a quando i campi richiesti non vengono popolati e registrati.

Si potrebbe utilizzare jQuery UI per agganciarsi all'evento di drop e poi guardare la pagina per ottenere l'ID corretto, quindi utilizzare gli aggiornamenti del servizio web per aggiornare in blocco i metadati dei file. Non ho visto esempi di questo tipo in giro, ma in teoria sembra fattibile.

Valutazioni e recensioni

Puoi aiutare il nostro saggio mostrando un commento o valutandolo, ti ringraziamo.



Utilizzate il nostro motore di ricerca

Ricerca
Generic filters

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.