Gerando relatórios em PDF em GO

OK. Agora gerando PDFs em GO!

Conteúdo da página

A geração de documentos PDF programaticamente pode ser uma funcionalidade importante no seu aplicativo. Aqui, exploramos e apresentamos uma breve revisão com exemplos das bibliotecas disponíveis na linguagem de programação Go (Golang) para geração de arquivos PDF.

As soluções adequadas podem variar para, por exemplo, a criação simples de documentos ou a geração de PDFs complexos e ricos em funcionalidades.

go, pdf! Sim, a imagem é gerada por IA, o modelo é Flux1.Dev.

Bibliotecas e Ferramentas

gofpdf

GoPdf é uma biblioteca direta para a criação de PDFs. Permite adicionar texto, imagens, formas, tabelas e gerenciar múltiplas páginas. Adequada para tarefas de criação de PDFs de simples a moderadamente complexas.

Mantenedor: Jung Kurt (descontinuado, mas ainda utilizado).

Limitação: Falta de atualizações, embora o uso existente persista.

Exemplo:

package main

import (
    "github.com/jung-kurt/gofpdf"
)

func main() {
    pdf := gofpdf.New("P", "mm", "A4", "")
    pdf.AddPage()
    pdf.SetFont("Arial", "B", 16)
    pdf.Cell(40, 10, "Hello World!")
    err := pdf.OutputFileAndClose("hello.pdf")
    if err != nil {
        panic(err)
    }
}

gopdf

Mantenedor: signintech (ativamente mantida).

Na linguagem de programação Go, uma das bibliotecas que se destaca para este propósito é a gopdf, desenvolvida pela SignInTech. Esta biblioteca oferece uma maneira simples de criar PDFs programaticamente, sem depender de dependências externas ou bibliotecas em C.

A gopdf é uma biblioteca em Go puro, projetada especificamente para a criação de documentos PDF. Ela oferece uma API simples e eficiente, focada principalmente na geração de PDFs, tornando-a mais fácil de usar para tarefas básicas, enquanto mantém a flexibilidade necessária para operações mais complexas.

Principais Características:

  • Implementação em Go Puro: Nenhuma dependência externa ou biblioteca em C necessária.
  • API Simples: Funções fáceis de usar para a geração de PDFs.
  • Desempenho Eficiente: Otimizado para a criação rápida e eficiente de PDFs.

Exemplo de Uso

Para ilustrar como a gopdf pode ser usada, vejamos um exemplo básico de criação de um documento PDF simples:

package main

import (
    "github.com/signintech/gopdf"
)

func main() {
    // Create a new PDF instance
    pdf := gopdf.New()

    // Set the page size and margins
    pdf.SetPageSize(gopdf.PageSizeA4)
    pdf.AddPage()

    // Add some text to the PDF
    pdf.SetFont("Arial", "", 12)
    pdf.Write(50, 50, "Hello, World!")

    // Save the PDF to a file
    err := pdf.SaveToFile("example.pdf")
    if err != nil {
        panic(err)
    }
}

Este exemplo demonstra como criar um novo documento PDF, adicionar texto a ele e salvá-lo como um arquivo.

Funcionalidades avançadas da gopdf:

  • Adição de Imagens: Você pode inserir imagens nos seus documentos PDF usando o método AddImage.
  • Desenho de Formas: A biblioteca fornece funções para desenhar linhas, retângulos e outras formas.
  • Proteção de PDF: Você pode definir proteção por senha nos seus PDFs para restringir o acesso.

pdfcpu

Outra das poderosas bibliotecas disponíveis para manipulação de PDFs em Go é a pdfcpu. Esta biblioteca oferece uma suíte abrangente de recursos para criar, modificar e inspecionar arquivos PDF, tanto através de uma API quanto de uma interface de linha de comandos (CLI). Abaixo, aprofundamos na descrição, exemplos de uso e funcionalidades principais da pdfcpu.

A pdfcpu é uma biblioteca de processamento de PDF baseada em Go que suporta criptografia e oferece ferramentas robustas para lidar com vários aspectos de documentos PDF. É compatível com todas as versões de PDF, incluindo melhorias contínuas para o PDF 2.0 (ISO-32000-2). A biblioteca visa fornecer uma gama abrangente de recursos de processamento de PDF, tornando-a adequada para casos de uso simples e complexos.

Principais Características

  • Suporte a Criptografia: A pdfcpu suporta criptografia, permitindo que os desenvolvedores protejam eficazmente seus documentos PDF.
  • API e CLI: Oferece tanto uma API para acesso programático quanto uma interface de linha de comandos (CLI) para operações rápidas.
  • Processamento em Lote: Forte suporte para processamento em lote através da interface de linha de comandos rica, tornando-a eficiente para lidar com múltiplos arquivos de uma vez.
  • Compatibilidade: Compatível com todas as versões de PDF, incluindo suporte básico e melhorias contínuas para o PDF 2.0.

Para começar a usar a pdfcpu, você precisa instalá-la usando o sistema de gerenciamento de pacotes do Go:

go get github.com/pdfcpu/pdfcpu

Operações Básicas de Linha de Comandos

A pdfcpu fornece uma variedade de comandos para diferentes operações. Aqui estão alguns exemplos:

Criando um PDF a partir de Imagens

Você pode converter um ou mais arquivos de imagem em um arquivo PDF com o seguinte comando:

pdfcpu img2pdf out.pdf image1.jpg image2.png

Este comando criará um PDF onde cada imagem é renderizada em uma página separada.

Para mesclar vários arquivos PDF em um único documento, use o comando merge:

pdfcpu merge output.pdf file1.pdf file2.pdf

Exemplo de uso da pdfcpu

Para operações mais complexas, você pode usar a API fornecida pela pdfcpu. Aqui está um exemplo de como criar um novo PDF e adicionar texto usando código Go:

package main

import (
    "github.com/pdfcpu/pdfcpu"
    "log"
)

func main() {
    // Create a new PDF document
    doc := pdfcpu.NewPDF(0, 0)
    defer doc.Close()

    // Add a page to the document
    page := doc.AddPage()
    page.SetMediaBox(pdfcpu.MediaBox{
        LLX: 0,
        LLY: 0,
        URX: 612,
        URY: 792,
    })

    // Add text to the page
    content := "Hello, World!"
    font := pdfcpu.NewFont("Helvetica", "")
    page.AddText(content, font, 12, 100, 750)

    // Save the document
    err := doc.Save("output.pdf")
    if err != nil {
        log.Fatal(err)
    }
}

Este exemplo demonstra como criar um novo PDF, adicionar uma página e escrever texto nela usando a API da pdfcpu.

Maroto

  • Mantenedor: equipe go-playground (https://github.com/go-playground/maroto).
  • Casos de Uso: Desenvolvedores que preferem uma abordagem centrada no design (semelhante ao Bootstrap).
  • Inspirado no Bootstrap; projetado para ser fácil de usar com um estilo declarativo semelhante ao HTML/CSS.
  • Construído sobre a gofpdf, simplifica o processo de criação, mantendo opções poderosas de personalização.

A Maroto é outra biblioteca Go para a criação de PDFs, mas ela se concentra em simplificar o processo ao abstrair os detalhes de baixo nível. Ela se baseia na biblioteca gofpdf e fornece uma API mais amigável para a geração de documentos.

Exemplo de Uso da Maroto

Aqui está um exemplo de como você pode usar a Maroto para criar um PDF simples:

package main

import (
    "github.com/andreyhoffmann1103/maroto"
)

func main() {
    // Create a new PDF document with specified dimensions
    m := maroto.NewPDF(595, 842) // A4 size in points

    // Add some text to the first page
    m.AddText("Hello, Maroto!", 0, 0)

    // Save the PDF to a file
    err := m.OutputFileAndClose("example.pdf")
    if err != nil {
        panic(err)
    }
}

Este exemplo mostra como criar um novo documento PDF com uma página e adicionar texto a ela usando a Maroto.

Unipdf

A UniPDF é outra biblioteca poderosa e abrangente para a criação e processamento de arquivos PDF em Golang (Go). Ela oferece uma ampla gama de recursos que a tornam popular entre desenvolvedores que precisam gerar, modificar e extrair conteúdo de documentos PDF.

  • Mantenedor: UnidocLib (https://unidoc.io).
  • Casos de Uso: Processamento avançado de PDF (criptografia, mesclagem, scripting).
  • Biblioteca poderosa para criação e processamento de PDFs (Go puro).
  • Oferece recursos extensos, incluindo elementos interativos como links, marcadores, mesclagem/divisão, criptografia e mais.
  • API abrangente para leitura e gravação de objetos PDF (dicionários, streams).
  • Adequada para aplicativos que necessitam de capacidades robustas de geração de PDF.

Instalação da UniPDF

Para começar a usar a UniPDF, você precisa instalar a biblioteca. Siga estes passos:

# Create a New Directory:
mkdir go-pdf-generator cd go-pdf-generator
# Initialize the Go Module:
go mod init go-pdf-generator
# Install UniPDF Library:
go get github.com/unidoc/unipdf/v3

Isso configurará seu projeto e instalará as dependências necessárias.

Exemplo Básico de Uso

Aqui está um exemplo simples para criar um documento PDF usando a UniPDF:

package main

import (
    "github.com/unidoc/unipdf/v3/core"
    "github.com/unidoc/unipdf/v3/model"
    "github.com/unidoc/unipdf/v3/creator"
)

func main() {
    // Create a new PDF document
    pdf := creator.New()

    // Add a page to the PDF
    page := pdf.NewPage()

    // Set up the content stream for the page
    contentStream := model.NewContentStream()
    page.SetContents(contentStream)

    // Add text to the page
    text := "Hello, UniPDF!"
    font := creator.NewStandardFont(creator.FontHelvetica)
    textObject := model.NewText(text, font, 12)
    contentStream.Add(textObject)

    // Save the PDF document
    err := pdf.WriteToFile("example.pdf")
    if err != nil {
        panic(err)
    }
}

Este exemplo demonstra como criar um novo documento PDF, adicionar uma página e escrever texto nela. O arquivo resultante example.pdf conterá o texto “Hello, UniPDF!”.

wkhtmltopdf Wrapper

Recursos:

  • Converte modelos HTML (renderizados com html/template do Go) em PDF.
  • Margens personalizáveis, orientação da página e cabeçalhos/rodapés.
  • Adequado quando o design do documento é complexo e envolve estilização HTML/CSS.
  • Usa o wkhtmltopdf como backend para converter conteúdo HTML em formato PDF.

Exemplo de uso do go-wkhtmltopdf

import (
    "bytes"
    "github.com/SebastiaanKlippert/go-wkhtmltopdf"
    "html/template"
)

type PDFService struct {}

func NewPDFService() *PDFService {
    return &PDFService{}
}

func (p PDFService) GeneratePDF(data interface{}) ([]byte, error) {
    var templ *template.Template
    var err error

    if templ, err = template.ParseFiles("pdf-template.html"); err != nil {
        return nil, err
    }

    var body bytes.Buffer
    if err := templ.Execute(&body, data); err != nil {
        return nil, err
    }

    pdfg, err := wkhtmltopdf.NewPDFGenerator()
    if err != nil {
        return nil, err
    }

    page := wkhtmltopdf.NewPageReader(bytes.NewReader(body.Bytes()))
    page.EnableLocalFileAccess.Set(true)

    pdfg.AddPage(page)
    pdfg.MarginLeft.Set(0)
    pdfg.MarginRight.Set(0)
    pdfg.Dpi.Set(300)
    pdfg.PageSize.Set(wkhtmltopdf.PageSizeA4)
    pdfg.Orientation.Set(wkhtmltopdf.OrientationLandscape)

    err = pdfg.Create()
    if err != nil {
        return nil, err
    }

    return pdfg.Bytes(), nil
}

pdflib (da EndFirstCorp):

  • Uma ferramenta de linha de comandos para diversas operações de PDF, como validação, otimização, divisão/mesclagem.
  • Útil para processamento em lote e tarefas administrativas relacionadas a documentos PDF.

Visão Geral da pdflib

A biblioteca pdflib é projetada para ser um processador de PDF abrangente para a linguagem de programação Go. Suporta diversas funcionalidades, como validação, otimização, divisão, mesclagem, extração de conteúdo e recorte de PDFs. A biblioteca segue o padrão PDF 32000-1:2008 (PDF 1.7), garantindo compatibilidade com uma ampla gama de documentos PDF.

Principais Características

  • Validação: Garante que os arquivos PDF estejam em conformidade com o padrão PDF 1.7.
  • Otimização: Reduz o tamanho do arquivo eliminando recursos redundantes.
  • Divisão e Mesclagem: Permite dividir PDFs multipágina em PDFs de página única ou mesclar vários PDFs em um só.
  • Extração: Extrai imagens, fontes, conteúdo e páginas de um PDF.
  • Recorte: Cria versões recortadas de documentos PDF.

Instalação

Para usar a pdflib, você precisa instalá-la através do sistema de gerenciamento de pacotes do Go. Você pode fazer isso executando:

go get github.com/EndFirstCorp/pdflib

Exemplo Básico de Uso - Validando um PDF

Aqui está um exemplo simples que demonstra como usar a biblioteca pdflib para realizar operações básicas de PDF:

Para validar um PDF em relação ao padrão PDF 1.7, você pode usar o seguinte código:

package main

import ( "fmt" "github.com/EndFirstCorp/pdflib/cmd/pdflib" )

func main() {
   // Validate a PDF file
   err := pdflib.Validate("example.pdf")
   if err != nil {
     fmt.Println("Validation failed:", err)
   } else {
     fmt.Println("PDF is valid.")
   }
}

Conclusão

Para a geração de PDFs em Go, a escolha da biblioteca depende da complexidade e dos requisitos específicos do seu projeto. As seguintes recomendações são fornecidas:

  • Documentos Simples: Use gofpdf ou Maroto. Estas bibliotecas oferecem simplicidade e facilidade de uso para tarefas diretas.
  • Designs Complexos com HTML/CSS: Utilize o wkhtmltopdf Wrapper, que aproveita o wkhtmltopdf para lidar com conteúdo e estilização HTML complexos.
  • Processamento Avançado de PDF: Opte por Unipdf ou pdfcpu quando seu aplicativo exigir recursos avançados, como criptografia, elementos interativos, formatação detalhada e capacidades de manipulação abrangentes.

Cada uma dessas bibliotecas oferece forças únicas que atendem a diferentes necessidades na geração de PDFs, fornecendo aos desenvolvedores uma variedade de ferramentas para escolher com base em seus requisitos específicos.

Subscrever

Receba novos artigos sobre sistemas, infraestrutura e engenharia de IA.