Hantera presentationsvarningar i PHP

Vad den här sidan handlar om

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

Översikt

Aspose.Slides kan rapportera återställbara problem när den läser in, renderar, konverterar eller sparar en presentation. Exempel inkluderar skadade källposter, innehåll som inte kan bevaras, teckensnittssubstitution och begränsningar i ett målformat. En varningscallback låter en applikation registrera dessa förhållanden och besluta om den aktuella operationen kan fortsätta.

Skapa en PHP-klass med en publik warning-metod och exponera den via PHP Java Bridge som Java‑gränssnittet IWarningCallback med hjälp av java_closure. Granska 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. Rendering‑ och exportalternativklasser ärver SaveOptions::setWarningCallback, som tar emot varningar från bild‑rendering, konvertering och sparande. Eftersom varningen själv inte identifierar vilken applikationsoperation som gäller, bör du associera varje callback‑instans med ett operationsstadium när du bygger en kombinerad rapport.

Varningar och Undantag

Java‑undantag exponeras för PHP via PHP Java Bridge; fånga dem vid operationens gräns, som visas i exemplet nedan. Java‑gränssnittslänkarna i den här artikeln beskriver det callback‑kontrakt som används av bryggan.

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

Att returnera ReturnAction::Abort ber varningsdistributören att avsluta den aktuella operationen genom att generera ett undantag. Det publika undantaget beror på operationen och presentationens format. Till exempel kan inläsning ge ett PptxReadException eller PptReadException, medan sparande eller export kan ge ett PptxException. Hantera undantaget vid operationens gräns och använd varningsrapporten för att avgöra om applikationspolicyn orsakade avslutet istället för att förlita dig på en specifik undantagstyp eller meddelande. Callbacken registrerar varningen innan den returnerar ReturnAction::Abort, vilket säkerställer 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äsning eller sparning.	Avbryt.
MajorFormattingLoss	Presentation kan förlora viktig formatering.	Avbryt i strikt valideringsläge; annars registrera och fortsätt.
MinorFormattingLoss	En begränsad formateringsskillnad kan uppstå.	Registrera för diagnostik och fortsätt.
CompatibilityIssue	Resultatet kanske inte öppnas eller fungerar korrekt i vissa program eller äldre versioner.	Logga och fortsätt om inte kompatibilitet är obligatorisk.
UnexpectedContent	Källan innehåller icke‑stödd eller oidentifierad innehåll vars effekt ä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 formulering i affärslogiken eftersom meddelandetexten kan variera mellan varningsscenario och produktversioner.

Samla in och klassificera varningar

Följande exempel använder en applikations‑nivårapport för hela bearbetningskedjan. En separat callback‑instans märker varningar från inläsning, rendering, PDF‑konvertering och PPTX‑sparande. Policyn avbryter vid källkorruption eller dataförlust, avbryter eventuellt vid större formateringsförlust, och fortsätter för övriga varningar. Callbacken konverterar varningsvärden till inhemska PHP‑värden med java_values innan de registreras och jämförs.

use aspose\slides\ImageFormat;
use aspose\slides\LoadOptions;
use aspose\slides\PdfOptions;
use aspose\slides\PptxOptions;
use aspose\slides\Presentation;
use aspose\slides\RenderingOptions;
use aspose\slides\ReturnAction;
use aspose\slides\SaveFormat;
use aspose\slides\WarningType;

class WarningReport {
    private $entries = [];

    public function getEntries() {
        return $this->entries;
    }

    public function add($stage, $type, $description) {
        $this->entries[] = [
            "stage" => $stage,
            "type" => $type,
            "description" => $description
        ];
    }
}

class WarningPolicy {
    private $abortOnMajorFormattingLoss;

    public function __construct($abortOnMajorFormattingLoss) {
        $this->abortOnMajorFormattingLoss = $abortOnMajorFormattingLoss;
    }

    public function getAction($warningType) {
        if ($warningType === WarningType::SourceFileCorruption || $warningType === WarningType::DataLoss) {
            return ReturnAction::Abort;
        }

        if ($warningType === WarningType::MajorFormattingLoss && $this->abortOnMajorFormattingLoss) {
            return ReturnAction::Abort;
        }

        return ReturnAction::Continue;
    }
}

class ReportingWarningCallback {
    private $stage;
    private $report;
    private $policy;

    public function __construct($stage, WarningReport $report, WarningPolicy $policy) {
        $this->stage = $stage;
        $this->report = $report;
        $this->policy = $policy;
    }

    public function warning($warning) {
        $type = (int) java_values($warning->getWarningType());
        $description = (string) java_values($warning->getDescription());
        $this->report->add($this->stage, $type, $description);
        return $this->policy->getAction($type);
    }
}

function createWarningCallback($stage, WarningReport $report, WarningPolicy $policy) {
    $handler = new ReportingWarningCallback($stage, $report, $policy);
    $warningInterface = java("com.aspose.slides.IWarningCallback");
    return java_closure($handler, null, $warningInterface);
}

function processPresentation($inputPath, WarningReport $report, WarningPolicy $policy) {
    try {
        $loadOptions = new LoadOptions();
        $callback = createWarningCallback("Loading", $report, $policy);
        $loadOptions->setWarningCallback($callback);

        $presentation = new 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 (Throwable $exception) {
        echo "Loading stopped: " . $exception->getMessage() . PHP_EOL;
        return false;
    }
}

function renderFirstSlide($presentation, WarningReport $report, WarningPolicy $policy) {
    if ((int) java_values($presentation->getSlides()->size()) === 0) {
        echo "Rendering stopped: the presentation has no slides." . PHP_EOL;
        return false;
    }

    try {
        $options = new RenderingOptions();
        $callback = createWarningCallback("Rendering", $report, $policy);
        $options->setWarningCallback($callback);

        $image = $presentation->getSlides()->get_Item(0)->getImage($options);
        try {
            $image->save("slide-1.png", ImageFormat::Png);
            return true;
        } finally {
            $image->dispose();
        }
    } catch (Throwable $exception) {
        echo "Rendering stopped: " . $exception->getMessage() . PHP_EOL;
        return false;
    }
}

function convertToPdf($presentation, WarningReport $report, WarningPolicy $policy) {
    try {
        $options = new PdfOptions();
        $callback = createWarningCallback("Conversion", $report, $policy);
        $options->setWarningCallback($callback);

        $presentation->save("converted.pdf", SaveFormat::Pdf, $options);
        return true;
    } catch (Throwable $exception) {
        echo "Conversion stopped: " . $exception->getMessage() . PHP_EOL;
        return false;
    }
}

function saveValidatedCopy($presentation, WarningReport $report, WarningPolicy $policy) {
    try {
        $options = new PptxOptions();
        $callback = createWarningCallback("Saving", $report, $policy);
        $options->setWarningCallback($callback);

        $presentation->save("validated-output.pptx", SaveFormat::Pptx, $options);
        return true;
    } catch (Throwable $exception) {
        echo "Saving stopped: " . $exception->getMessage() . PHP_EOL;
        return false;
    }
}

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

$report = new WarningReport();
$policy = new WarningPolicy(true);
$completed = processPresentation("input.pptx", $report, $policy);

echo ($completed ? "Processing completed." : "Processing stopped.") . PHP_EOL;

foreach ($report->getEntries() as $entry) {
    $typeName = warningTypeName($entry["type"]);
    echo "[" . $entry["stage"] . "] " . $typeName . ": " . $entry["description"] . PHP_EOL;
}

Skicka false för abortOnMajorFormattingLoss när du konstruerar WarningPolicy om stora formateringsavvikelser ä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 varningsscenarier

Varningar kan uppstå i olika steg av ett arbetsflöde:

Digital signaturer: En signerad presentation kan ge en varning vid inläsning att dess signatur kommer att gå förlorad under bearbetning. Aspose.Slides rapporterar detta DataLoss‑tillstånd via IPresentationSignedWarningInfo. En inläsnings‑stadie‑callback låter applikationen avvisa filen eller explicit acceptera den rapporterade förlusten.
Teckensnittssubstitution: Ett otillgängligt teckensnitt kan ersättas medan en bild renderas eller exporteras. Varningsmeddelanden om teckensnittssubstitution rapporteras som DataLoss, så den strikta policyn ovan avbryter även om applikationen skulle betrakta en viss ersättning som visuellt acceptabel. För att observera detta beteende, använd en inmatningspresentation som innehåller text i ett teckensnitt som inte är tillgängligt för körmiljön. Varningsbeskrivningen identifierar ersättningen; konfigurera de erforderliga teckensnitten eller teckensnittssubstitutionsregler innan du försöker igen.
Ej stödd eller oväntad innehåll: En inläsare 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ända för att vara påverkade.
Formatkompatibilitet: Att spara till ett annat presentationsformat kan utelämna funktioner eller producera ett resultat som beter sig annorlunda i vissa program. Till exempel rapporterar sparande av en presentation med mer än åtta horisontella eller åtta vertikala ritningsguider till äldre PPT ett CompatibilityIssue. Spar‑stadie‑callbacken kan registrera förlusten och fortsätta, eller avvisa den om bevarande av alla guider krävs.
Inläsningsbeteende: Inläsningsalternativ 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 motsvarar en enda 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 läsas in och får inte anta att en rendering‑ eller sparutdata är komplett. Operationen kan avslutas efter att en utdatafil 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 efter att operationen har slutförts framgångsrikt, varningsrapporten uppfyller applikationspolicyn och utdata kan öppnas och kontrolleras. Detta förhindrar att en giltig källfil skrivs över med ett partiellt eller avvisat resultat.

En tom varningsrapport garanterar inte att varje källfunktion har bevarats. Tillämpa eventuella ytterligare innehålls‑ och visuella kontroller som krävs av applikationen. Se även Open Presentations och Save Presentations.

FAQ

Kan en varningscallback hantera varje Aspose.Slides‑fel?

Nej. Den hanterar återställbara tillstånd som rapporteras som varningar. Undantag som inträffar oberoende av callbacken måste hanteras av applikationen runt inläsning, rendering, konvertering eller sparningsanropet.

Garanterar returnering av ReturnAction::Continue identiskt resultat?

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

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

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

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