Hantera presentationsvarningar i Node.js

Vad den här sidan handlar om

Lär dig hur du samlar in, klassificerar och hanterar varningar när du laddar, renderar, konverterar och sparar presentationer med Aspose.Slides för Node.js via Java.

Översikt

Aspose.Slides kan rapportera återställningsbara problem när den laddar, renderar, konverterar eller sparar en presentation. Exempel inkluderar skadade källposter, innehåll som inte kan bevaras, teckensnittsersättning och begränsningar i ett målformat. En varnings‑callback låter en applikation registrera dessa förhållanden och besluta om den pågående operationen får fortsätta.

Använd java.newProxy för att implementera IWarningCallback‑gränssnittet i JavaScript och undersök värdena från getWarningType och getDescription som levereras via IWarningInfo. Returnera ReturnAction.Continue för att acceptera varningen eller ReturnAction.Abort för att stoppa operationen.

Använd LoadOptions.setWarningCallback för varningar som uppstår när en presentation öppnas. Renderings‑ och exportalternativklasser ärver SaveOptions.setWarningCallback, som tar emot varningar från bildrendering, konvertering och sparning. Eftersom själva varningen inte identifierar vilken applikationsoperation som gjorts, bör varje callback‑instans kopplas till ett operation‑steg när du bygger en samlad rapport.

Varningar och Undantag

En varning beskriver ett tillstånd som Aspose.Slides kan återhämta sig från om callbacken returnerar ReturnAction.Continue. Ett undantag betyder att den begärda operationen inte kan slutföras normalt; undantag omvandlas inte till varningar och kan inte hanteras av en varningspolicy.

Genom att returnera ReturnAction.Abort begärs varningsdistributören att avsluta den pågående operationen genom att kasta ett undantag. Det offentliga undantaget beror på operationen och presentationsformatet. Till exempel kan laddning resultera i ett PptxReadException eller PptReadException, medan sparning eller export kan ge ett PptxException. Fånga felet från Java‑bron vid operationens gräns och använd varningsrapporten för att avgöra om applikationspolicyn orsakade avslutet i stället för att förlita dig på en enda undantagstyp eller meddelande. Callbacken registrerar varningen innan ReturnAction.Abort returneras, så att orsaken förblir tillgänglig för applikationen.

Varningskategorier

Klassen WarningType tillhandahåller heltalskonstanter för följande kategorier:

Varningstyp	Betydelse	Typisk policy
SourceFileCorruption	Källpresentationen innehåller korruption som kan göra ett dokument sparat i dess ursprungsformat oanvändbart.	Avbryt.
DataLoss	Text, diagram, bilder eller annan data kan saknas efter inläst eller sparat.	Avbryt.
MajorFormattingLoss	Presentation kan förlora viktig formatering.	Avbryt i strikt valideringsläge; annars registrera och fortsätt.
MinorFormattingLoss	En begränsad formateringsskillnad kan förekomma.	Registrera för diagnostik och fortsätt.
CompatibilityIssue	Resultatet kanske inte öppnas eller beter sig korrekt i vissa program eller äldre versioner.	Logga och fortsätt om inte kompatibilitet är obligatorisk.
UnexpectedContent	Källan innehåller icke‑stött eller oigenkännt innehåll vars effekt kanske ännu inte är känd.	Registrera och fortsätt, eller behandla som ett fel i en strikt policy.

Kategorin bör styra policybeslutet. Spara värdet som returneras av getDescription för diagnostik, men förlita dig inte på dess ordalydelse i applikationslogiken eftersom meddelandetexten kan variera mellan varningsscenarier och produktversioner.

Samla och Klassificera Varningar

Följande JavaScript‑exempel använder en applikations‑nivårapport för hela behandlings‑pipeline. En separat callback‑instans märker varningar från laddning, rendering, PDF‑konvertering och PPTX‑sparning. Policyn avbryter vid källkorruption eller dataförlust, avbryter eventuellt vid stor formateringsförlust och fortsätter för övriga varningar.

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);
}

Skicka false för abortOnMajorFormattingLoss när du konstruerar WarningPolicy om stora formateringsskillnader är acceptabla. Kompatibilitetsproblem, mindre formateringsförlust och oväntat innehåll behålls fortfarande i rapporten även när operationen fortsätter. Utöka WarningPolicy.getAction om applikationen måste avvisa någon av dessa kategorier.

Vanliga Varningsscenario

Varningar kan visas i olika steg av ett arbetsflöde:

Digital signatures: En signerad presentation kan ge en varning under laddning om att dess signatur går förlorad under bearbetning. Aspose.Slides rapporterar detta DataLoss‑tillstånd via IPresentationSignedWarningInfo. En callback i laddningsstadiet låter applikationen avvisa filen eller explicit acceptera den rapporterade förlusten.
Font substitution: Ett otillgängligt teckensnitt kan ersättas medan en bild renderas eller exporteras. Varningar om teckensnittsersättning rapporteras som DataLoss, så den strikta policyn ovan avbryter även om applikationen skulle anse ersättningen visuellt acceptabel. För att observera detta beteende, använd en input‑presentation som innehåller text i ett teckensnitt som inte finns tillgängligt för körningen. Varningsbeskrivningen identifierar ersättningen; konfigurera de nödvändiga teckensnitten eller font substitution rules innan du försöker igen.
Unsupported or unexpected content: En laddare kan stöta på presentationsposter eller funktioner den inte känner igen. Sådana varningar kan använda UnexpectedContent, eller en allvarligare kategori när data eller formatering är känt att påverkas.
Format compatibility: Sparning till ett annat presentationsformat kan utelämna funktioner eller skapa ett resultat som beter sig annorlunda i vissa program. Till exempel rapporterar sparning av en presentation med mer än åtta horisontella eller åtta vertikala ritningsguider till äldre PPT ett CompatibilityIssue. Callbacken i sparningsstadiet kan registrera förlusten och fortsätta, eller avvisa den om alla guider måste bevaras.
Loading behavior: Laddningsalternativ och äldre beteenden kan också ge varningar. Till exempel identifierar IObsoletePresLockingBehaviorWarningInfo användning av ett föråldrat presentations‑låsningsbeteende som ett CompatibilityIssue.

Varningar beror på källdokumentet, målformatet, operationen och Aspose.Slides‑versionen. Anta inte att varje fil ger en varning eller att ett scenario alltid matchar endast en kategori.

Hantera Avbrutna Operationer På Ett Säkert Sätt

När en callback returnerar ReturnAction.Abort får du inte använda ett objekt som misslyckades att laddas och får inte anta att en renderings‑ eller sparutdata är fullständig. Operationen kan avslutas efter att en utdatafil har skapats men innan den är färdig.

Spara validerade resultat till en separat sökväg, t.ex. validated-output.pptx. Ersätt en befintlig presentation först när operationen har slutförts framgångsrikt, varningsrapporten uppfyller applikationspolicyn och utdata kan öppnas och kontrolleras. Detta undviker att skriva över en giltig källfil med ett partiellt eller avvisat resultat.

En tom varningsrapport garanterar inte att alla källfunktioner har bevarats. Applicera eventuella ytterligare innehålls‑ och visuella kontroller som krävs av applikationen. Se också Open Presentations och Save Presentations.

FAQ

Kan en varningscallback hantera varje Aspose.Slides‑fel?

Nej. Den hanterar återställningsbara förhållanden som rapporteras som varningar. Undantag som uppstår oberoende av callbacken måste hanteras av applikationen runt laddnings‑, renderings‑, konverterings‑ eller sparningsanropet.

Garanterar att returnera ReturnAction.Continue ett identiskt utdata?

Nej. Det tillåter bara att behandlingen fortsätter. Det rapporterade tillståndet kan fortfarande orsaka data‑, formaterings‑ eller kompatibilitetsavvikelser, så granska de insamlade varningstyperna och beskrivningarna.

Hur kan en applikation identifiera vilken operation som genererade en varning?

Skapa en callback‑instans för varje operation och lagra ett applikations‑definierat steg tillsammans med värdena som returneras av getWarningType och getDescription, som visas i exemplet.

Hämta hela bildbakgrunden från en presentation som en bild