Manipola il contenuto dei PDF con la nuova API per ONLYOFFICE PDF Editor

ONLYOFFICE ha recentemente introdotto una nuova API per PDF, portando il supporto alle macro nel PDF. Con questi nuovi metodi, è possibile interagire con i documenti PDF in modo programmatico, automatizzando attività che altrimenti richiederebbero un intervento manuale. In questo articolo del blog, scopriremo tre pratiche macro che dimostrano cosa si può fare con la nuova API.

Nuovi metodi della API per PDF

Ecco una panoramica dei nuovi metodi utilizzati nei tre esempi di macro:

• GetPagesCount() — restituisce il numero totale di pagine nel documento PDF.
• GetPage(index) — recupera uno specifico oggetto pagina tramite il suo indice, restituendo un oggetto ApiPage.
• GetAllAnnots() — restituisce un array di tutti gli oggetti annotazione presenti in una determinata pagina.
• GetContents() — recupera il contenuto testuale di un’annotazione.
• GetAllDrawings() — restituisce un array di tutti gli oggetti di disegno (forme, grafici, immagini).
• SetPosition(x, y) — posiziona un oggetto di disegno direttamente sulla pagina utilizzando coordinate assolute.
• AddObject(object) — aggiunge un oggetto di disegno (forma, grafico, immagine) a una pagina specifica.
• Delete() — rimuove l’oggetto specificato dal documento.

Questi metodi appartengono alle classi ApiDocument, ApiPage, ApiBaseAnnotation e ApiDrawing. Possono essere combinati con i metodi esistenti dell’Office API con cui potreste già avere familiarità.

Esempio 1: Rimuovere le annotazioni tramite parola chiave

La prima macro individua ed elimina tutte le annotazioni che contengono una parola chiave specifica. Analizziamola passo dopo passo.

Impostazione della parola chiave e del documento

const KEYWORD = "example";
const doc = Api.GetDocument();
const pagesCount = doc.GetPagesCount();
let deletedCount = 0;

Per prima cosa, definiamo la parola chiave di destinazione: qualsiasi annotazione il cui contenuto includa questa parola verrà rimossa. Dopodiché, recuperiamo il documento corrente e otteniamo il numero totale di pagine con GetPagesCount(). La variabile deletedCount terrà traccia del numero di annotazioni eliminate.

for (let i = 0; i < pagesCount; i++) {
    const page = doc.GetPage(i);
    const annots = page.GetAllAnnots();

    if (!annots || annots.length === 0) continue;

Un ciclo for scorre ogni pagina. Per ciascuna pagina, utilizziamo GetPage() per ottenere l’oggetto ApiPage e GetAllAnnots() per recuperare tutte le annotazioni presenti. Se una pagina non contiene annotazioni, la saltiamo e passiamo alla successiva.

Corrispondenza ed eliminazione delle annotazioni

for (let j = annots.length - 1; j >= 0; j--) {
    const annot = annots[j];
    const contents = (annot.GetContents() || "").toLowerCase();

All’interno di ogni pagina, scorriamo le annotazioni in ordine inverso. Iterare a ritroso è importante perché eliminare elementi da un array procedendo in avanti può causare slittamenti degli indici e il salto di alcuni elementi. Per ogni annotazione, estraiamo il testo con GetContents() e lo convertiamo in minuscolo per un confronto senza distinzione tra maiuscole e minuscole.

if (contents.includes(KEYWORD.toLowerCase())) {
    annot.Delete();
    deletedCount++;
}

Se il testo dell’annotazione include la parola chiave di destinazione, chiamiamo Delete() per rimuoverla dal documento e incrementiamo il contatore.

console.log("Deleted annotations containing keyword:", KEYWORD);

console.log("Total deleted:", deletedCount);

Al termine, la macro registra nella console la parola chiave cercata e il numero totale di annotazioni eliminate.

Il codice completo della macro:

(function () {
    const KEYWORD = "example";
    const doc = Api.GetDocument();
    const pagesCount = doc.GetPagesCount();
    let deletedCount = 0;

    for (let i = 0; i < pagesCount; i++) {
        const page = doc.GetPage(i);
        const annots = page.GetAllAnnots();

        if (!annots || annots.length === 0) continue;

        for (let j = annots.length - 1; j >= 0; j--) {
            const annot = annots[j];
            const contents = (annot.GetContents() || "").toLowerCase();

            if (contents.includes(KEYWORD.toLowerCase())) {
                annot.Delete();
                deletedCount++;
            }
        }
    }

    console.log("Deleted annotations containing keyword:", KEYWORD);
    console.log("Total deleted:", deletedCount);
})();

Una volta eseguita la macro, ogni annotazione contenente la parola chiave specificata viene rimossa dal documento. Per individuare una parola diversa, è sufficiente aggiornare la variabile KEYWORD in cima al codice.

Esempio 2: Rimuovere tutti i disegni

Questa macro analizza ogni pagina ed elimina tutti gli oggetti di disegno, oppure solo un tipo specifico. Utilizza GetAllDrawings() per recuperare tutti gli elementi visivi di ogni pagina e GetClassType() per verificarne il tipo prima di eliminarli.

La variabile targetType in cima al codice controlla cosa viene rimosso. Impostarla su “all” per rimuovere tutto, oppure usare “shape”, “image” o “chart” per selezionare un tipo specifico di disegno.

(function () {
    const doc = Api.GetDocument();
    const pagesCount = doc.GetPagesCount();
    let totalDeleted = 0;

    const targetType = "all";

    for (let i = 0; i < pagesCount; i++) {
        const page = doc.GetPage(i);
        const drawings = page.GetAllDrawings();

        for (let j = 0; j < drawings.length; j++) {
            if (targetType === "all" || drawings[j].GetClassType() === targetType) {
                drawings[j].Delete();
                totalDeleted++;
            }
        }
    }

    console.log("Deleted " + totalDeleted + " drawing(s) from " + pagesCount + " page(s).");
})();

Che si stia preparando un documento per la stampa, rimuovendo diagrammi obsoleti o eliminando immagini prima della ridistribuzione, questa macro se ne occupa. Modificando la variabile targetType, è possibile passare da una pulizia completa a una selettiva senza dover modificare nessun’altra parte del codice.

Esempio 3: Aggiungere una filigrana a ogni pagina

L’ultima macro crea una forma filigrana personalizzabile e la inserisce in ogni pagina del documento. Utilizza SetPosition() per posizionare la forma con coordinate precise sulla pagina e AddObject() per aggiungerla a ciascuna pagina.

Tutte le proprietà principali sono definite come variabili in cima al codice, rendendo semplice modificare il testo della filigrana, i colori, la dimensione del carattere, la posizione e l’angolo di rotazione.

(function () {
    const doc = Api.GetDocument();
    const pagesCount = doc.GetPagesCount();

    const watermarkText = "DRAFT";
    const bgColor = Api.CreateRGBColor(200, 200, 200);
    const textColor = Api.CreateRGBColor(255, 255, 255);
    const fontSize = 72;
    const positionX = 1200000;
    const positionY = 4000000;
    const rotation = -45;

    for (let i = 0; i < pagesCount; i++) {
        const page = doc.GetPage(i);
        const fill = Api.CreateSolidFill(bgColor);
        const stroke = Api.CreateStroke(0, Api.CreateNoFill());
        const watermark = Api.CreateShape("rect", 160 * 36000, 20 * 36000, fill, stroke);
        watermark.SetPosition(positionX, positionY);
        watermark.SetRotation(rotation);

        const content = watermark.GetContent();
        const para = content.GetElement(0);
        para.SetJc("center");
        const run = para.AddText(watermarkText);
        run.SetFontSize(fontSize);
        run.SetBold(true);
        run.SetFill(Api.CreateSolidFill(textColor));

        page.AddObject(watermark);
    }
})();

La filigrana è costruita a partire da una forma standard con contenuto testuale, offrendo il pieno controllo sul suo aspetto, dalle etichette di sfondo discrete ai timbri in grassetto a pagina intera. È anche possibile sperimentare con diverse dimensioni della forma, stili di carattere o angoli di rotazione per trovare l’aspetto più adatto ai propri documenti.

Queste tre macro sono solo un punto di partenza: la nuova PDF API apre molte altre possibilità per automatizzare i flussi di lavoro con i PDF. È possibile combinare questi metodi per creare macro più avanzate, su misura per le proprie esigenze specifiche. Esplorate la documentazione dell’API e gli esempi di macro nei link qui sotto per ulteriori idee. Per qualsiasi domanda o per condividere ciò che avete realizzato, non esitate a contattarci!