Gestire gli avvisi della presentazione in Node.js

Di cosa tratta questa pagina

Impara a raccogliere, classificare e gestire gli avvisi durante il caricamento, il rendering, la conversione e il salvataggio delle presentazioni con Aspose.Slides per Node.js via Java.

Panoramica

Aspose.Slides può segnalare problemi recuperabili durante il caricamento, il rendering, la conversione o il salvataggio di una presentazione. Gli esempi includono record di origine danneggiati, contenuti che non possono essere preservati, sostituzione dei caratteri e limitazioni di un formato di destinazione. Un callback di avviso consente a un’applicazione di registrare queste condizioni e decidere se l’operazione corrente può continuare.

Usa java.newProxy per implementare l’interfaccia Java IWarningCallback in JavaScript ed esaminare i valori getWarningType e getDescription forniti tramite IWarningInfo. Restituisci ReturnAction.Continue per accettare l’avviso o ReturnAction.Abort per interrompere l’operazione.

Usa LoadOptions.setWarningCallback per gli avvisi generati durante l’apertura di una presentazione. Le classi di opzioni di rendering ed esportazione ereditano SaveOptions.setWarningCallback, che riceve avvisi dal rendering delle diapositive, dalla conversione e dal salvataggio. Poiché l’avviso stesso non identifica l’operazione dell’applicazione, associa ogni istanza del callback a una fase dell’operazione quando crei un report combinato.

Avvisi ed Eccezioni

Un avviso descrive una condizione da cui Aspose.Slides può recuperare se il callback restituisce ReturnAction.Continue. Un’eccezione indica che l’operazione richiesta non può completarsi normalmente; le eccezioni non vengono convertite in avvisi e non possono essere gestite da una politica di avviso.

Restituire ReturnAction.Abort chiede al dispatcher degli avvisi di terminare l’operazione corrente sollevando un’eccezione. L’eccezione pubblica dipende dall’operazione e dal formato della presentazione. Ad esempio, il caricamento può generare una PptxReadException o una PptReadException, mentre il salvataggio o l’esportazione possono generare una PptxException. Cattura l’errore dal bridge Java al confine dell’operazione e utilizza il report degli avvisi per determinare se la politica dell’applicazione ha causato la terminazione invece di fare affidamento su un sottotipo o messaggio di eccezione. Il callback registra l’avviso prima di restituire ReturnAction.Abort, garantendo che il motivo rimanga disponibile per l’applicazione.

Categorie di Avviso

La classe WarningType fornisce costanti intere per le seguenti categorie:

Tipo di avviso	Significato	Politica tipica
SourceFileCorruption	La presentazione di origine contiene corruzione che può rendere inutilizzabile un documento salvato nel suo formato originale.	Interrompi.
DataLoss	Testo, grafici, immagini o altri dati potrebbero mancare dopo il caricamento o il salvataggio.	Interrompi.
MajorFormattingLoss	La presentazione potrebbe perdere formattazioni importanti.	Interrompi in modalità di validazione stretta; altrimenti registra e continua.
MinorFormattingLoss	Potrebbe verificarsi una piccola differenza di formattazione.	Registra per la diagnostica e continua.
CompatibilityIssue	Il risultato potrebbe non aprirsi o comportarsi correttamente in alcune applicazioni o versioni più vecchie.	Registra nel log e continua a meno che la compatibilità non sia obbligatoria.
UnexpectedContent	La sorgente contiene contenuti non supportati o non riconosciuti il cui effetto potrebbe non essere ancora noto.	Registra e continua, o tratta come errore in una politica rigida.

La categoria dovrebbe guidare la decisione della politica. Conserva il valore restituito da getDescription per la diagnostica, ma non fare affidamento sulla sua formulazione per la logica dell’applicazione poiché il testo del messaggio può variare tra scenari di avviso e versioni del prodotto.

Raccogliere e Classificare gli Avvisi

Il seguente esempio JavaScript utilizza un unico report a livello di applicazione per l’intera pipeline di elaborazione. Un’istanza di callback separata etichetta gli avvisi provenienti dal caricamento, dal rendering, dalla conversione PDF e dal salvataggio PPTX. La politica interrompe in caso di corruzione della sorgente o perdita di dati, opzionalmente interrompe in caso di perdita di formattazione importante e continua per gli altri avvisi.

const java = require("java");
var aspose = aspose || {};
aspose.slides = require("aspose.slides.via.java");

class WarningPolicy {
    constructor(abortOnMajorFormattingLoss) {
        this.abortOnMajorFormattingLoss = abortOnMajorFormattingLoss;
    }

    getAction(warningType) {
        if (warningType === aspose.slides.WarningType.SourceFileCorruption || warningType === aspose.slides.WarningType.DataLoss) {
            return aspose.slides.ReturnAction.Abort;
        }

        if (warningType === aspose.slides.WarningType.MajorFormattingLoss && this.abortOnMajorFormattingLoss) {
            return aspose.slides.ReturnAction.Abort;
        }

        return aspose.slides.ReturnAction.Continue;
    }
}

function createReportingWarningCallback(stage, report, policy) {
    return java.newProxy("com.aspose.slides.IWarningCallback", {
        warning: function (warning) {
            const type = warning.getWarningType();
            const description = warning.getDescription();
            report.push({ stage, type, description });
            return policy.getAction(type);
        }
    });
}

function processPresentation(inputPath, report, policy) {
    try {
        const loadOptions = new aspose.slides.LoadOptions();
        const callback = createReportingWarningCallback("Loading", report, policy);
        loadOptions.setWarningCallback(callback);

        const presentation = new aspose.slides.Presentation(inputPath, loadOptions);
        try {
            if (!renderFirstSlide(presentation, report, policy)) {
                return false;
            }

            if (!convertToPdf(presentation, report, policy)) {
                return false;
            }

            return saveValidatedCopy(presentation, report, policy);
        } finally {
            presentation.dispose();
        }
    } catch (error) {
        console.error("Loading stopped: " + error.message);
        return false;
    }
}

function renderFirstSlide(presentation, report, policy) {
    if (presentation.getSlides().size() === 0) {
        console.error("Rendering stopped: the presentation has no slides.");
        return false;
    }

    try {
        const options = new aspose.slides.RenderingOptions();
        const callback = createReportingWarningCallback("Rendering", report, policy);
        options.setWarningCallback(callback);

        const image = presentation.getSlides().get_Item(0).getImage(options);
        try {
            image.save("slide-1.png", aspose.slides.ImageFormat.Png);
            return true;
        } finally {
            image.dispose();
        }
    } catch (error) {
        console.error("Rendering stopped: " + error.message);
        return false;
    }
}

function convertToPdf(presentation, report, policy) {
    try {
        const options = new aspose.slides.PdfOptions();
        const callback = createReportingWarningCallback("Conversion", report, policy);
        options.setWarningCallback(callback);

        presentation.save("converted.pdf", aspose.slides.SaveFormat.Pdf, options);
        return true;
    } catch (error) {
        console.error("Conversion stopped: " + error.message);
        return false;
    }
}

function saveValidatedCopy(presentation, report, policy) {
    try {
        const options = new aspose.slides.PptxOptions();
        const callback = createReportingWarningCallback("Saving", report, policy);
        options.setWarningCallback(callback);

        presentation.save("validated-output.pptx", aspose.slides.SaveFormat.Pptx, options);
        return true;
    } catch (error) {
        console.error("Saving stopped: " + error.message);
        return false;
    }
}

function warningTypeName(warningType) {
    switch (warningType) {
        case aspose.slides.WarningType.SourceFileCorruption:
            return "SourceFileCorruption";
        case aspose.slides.WarningType.DataLoss:
            return "DataLoss";
        case aspose.slides.WarningType.MajorFormattingLoss:
            return "MajorFormattingLoss";
        case aspose.slides.WarningType.MinorFormattingLoss:
            return "MinorFormattingLoss";
        case aspose.slides.WarningType.CompatibilityIssue:
            return "CompatibilityIssue";
        case aspose.slides.WarningType.UnexpectedContent:
            return "UnexpectedContent";
        default:
            return "Unknown (" + warningType + ")";
    }
}

const report = [];
const policy = new WarningPolicy(true);
const completed = processPresentation("input.pptx", report, policy);

console.log(completed ? "Processing completed." : "Processing stopped.");

for (const entry of report) {
    const typeName = warningTypeName(entry.type);
    console.log("[" + entry.stage + "] " + typeName + ": " + entry.description);
}

Passa false per abortOnMajorFormattingLoss durante la costruzione di WarningPolicy se le differenze di formattazione importanti sono accettabili. I problemi di compatibilità, la perdita di formattazione minore e i contenuti inaspettati vengono comunque mantenuti nel report anche quando l’operazione continua. Estendi WarningPolicy.getAction se l’applicazione deve rifiutare una di queste categorie.

Scenari di Avviso Comuni

Gli avvisi possono apparire in diverse fasi di un flusso di lavoro:

Digital signatures: Una presentazione firmata può generare un avviso durante il caricamento indicando che la firma verrà persa durante l’elaborazione. Aspose.Slides segnala questa condizione DataLoss tramite IPresentationSignedWarningInfo. Un callback nella fase di caricamento consente all’applicazione di rifiutare il file o di accettare esplicitamente la perdita segnalata.
Font substitution: Un carattere non disponibile può essere sostituito durante il rendering o l’esportazione di una diapositiva. Gli avvisi di sostituzione dei caratteri sono segnalati come DataLoss, quindi la politica rigida sopra interrompe anche se l’applicazione considererebbe una specifica sostituzione accettabile visivamente. Per osservare questo comportamento, utilizza una presentazione di input contenente testo in un carattere non disponibile al runtime. La descrizione dell’avviso identifica la sostituzione; configura i caratteri richiesti o le regole di sostituzione dei caratteri prima di riprovare.
Unsupported or unexpected content: Un loader può incontrare record o funzionalità della presentazione che non riconosce. Tali avvisi possono utilizzare UnexpectedContent, o una categoria più severa quando si sa che dati o formattazione sono interessati.
Format compatibility: Il salvataggio in un altro formato di presentazione può omettere funzionalità o produrre un risultato che si comporta diversamente in alcune applicazioni. Per esempio, salvare una presentazione con più di otto guide di disegno orizzontali o otto verticali in un PPT legacy genera un CompatibilityIssue. Il callback nella fase di salvataggio può registrare la perdita e continuare, o rifiutarla se è necessario preservare tutte le guide.
Loading behavior: Le opzioni di caricamento e i comportamenti legacy possono anche generare avvisi. Per esempio, IObsoletePresLockingBehaviorWarningInfo identifica l’uso di un comportamento di blocco della presentazione obsoleto come un CompatibilityIssue.

Gli avvisi dipendono dal documento di origine, dal formato di destinazione, dall’operazione e dalla versione di Aspose.Slides. Non presumere che ogni file generi un avviso o che uno scenario corrisponda sempre a una sola categoria.

Gestire in Sicurezza le Operazioni Interrotte

Quando un callback restituisce ReturnAction.Abort, non utilizzare un oggetto che non è stato caricato e non presumere che un output di rendering o salvataggio sia completo. L’operazione può terminare dopo aver creato un file di output ma prima di averlo completato.

Salva i risultati convalidati in un percorso separato, ad esempio validated-output.pptx. Sostituisci una presentazione esistente solo dopo che l’operazione è terminata con successo, il report degli avvisi soddisfa la politica dell’applicazione e l’output può essere aperto e verificato. Questo evita di sovrascrivere un file di origine valido con un risultato parziale o rifiutato.

Un report di avviso vuoto non garantisce che ogni funzionalità di origine sia stata preservata. Applica eventuali controlli aggiuntivi di contenuto e visivi richiesti dall’applicazione. Vedi anche Open Presentations e Save Presentations.

FAQ

Il callback di avviso può gestire tutti gli errori di Aspose.Slides?

No. Gestisce condizioni recuperabili segnalate come avvisi. Le eccezioni che si verificano indipendentemente dal callback devono essere gestite dall’applicazione attorno alla chiamata di caricamento, rendering, conversione o salvataggio.

Restituire ReturnAction.Continue garantisce un output identico?

No. Consente solo di continuare l’elaborazione. La condizione segnalata può comunque causare differenze di dati, formattazione o compatibilità, quindi esamina i tipi di avviso e le descrizioni raccolti.

Come può un’applicazione identificare l’operazione che ha prodotto un avviso?

Crea un’istanza di callback per ogni operazione e memorizza una fase definita dall’applicazione insieme ai valori restituiti da getWarningType e getDescription, come mostrato nell’esempio.

Ottenere l'intero sfondo della diapositiva da una presentazione come immagine