Gerando relatórios PDF em GO

Certo. Agora gerando PDFs no GO!

Conteúdo da página

A geração programática de documentos PDF pode ser um recurso importante na sua aplicação. Aqui, exploramos e apresentamos uma breve revisão com exemplos das bibliotecas disponíveis na linguagem de programação Go (Golang) para gerar arquivos PDF.

Soluções adequadas podem variar, por exemplo, para criação de documentos simples ou para geração de PDF complexa e rica em recursos.

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

Bibliotecas e Ferramentas

gofpdf

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

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 esse propósito é a gopdf, desenvolvida pela SignInTech. Esta biblioteca oferece uma maneira direta de criar PDFs programaticamente sem depender de dependências externas ou bibliotecas C.

A gopdf é uma biblioteca pura em Go projetada especificamente para criar documentos PDF. Oferece uma API simples e eficiente focada principalmente na geração de PDF, tornando-a mais fácil de usar para tarefas básicas, mantendo ao mesmo tempo a flexibilidade necessária para operações mais complexas.

Principais Funcionalidades:

  • Implementação Pura em Go: Sem dependências externas ou bibliotecas C necessárias.
  • API Simples: Funções fáceis de usar para gerar PDFs.
  • Desempenho Eficiente: Otimizado para criação rápida e eficiente de PDFs.

Exemplo de Uso

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

package main

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

func main() {
    // Crie uma nova instância de PDF
    pdf := gopdf.New()

    // Defina o tamanho da página e as margens
    pdf.SetPageSize(gopdf.PageSizeA4)
    pdf.AddPage()

    // Adicione algum texto ao PDF
    pdf.SetFont("Arial", "", 12)
    pdf.Write(50, 50, "Hello, World!")

    // Salve o PDF em um arquivo
    err := pdf.SaveToFile("example.pdf")
    if err != nil {
        panic(err)
    }
}

Este exemplo demonstra como criar um novo documento PDF, adicionar texto a ele e salvar como arquivo.

Funcionalidades Avançadas da gopdf:

  • Adição de Imagens: Você pode inserir imagens em 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 em seus PDFs para restringir o acesso.

pdfcpu

Outra das bibliotecas poderosas disponíveis para manipulação de PDF em Go é a pdfcpu. Esta biblioteca oferece uma suíte abrangente de recursos para criar, modificar e inspecionar arquivos PDF através tanto de uma API quanto de uma interface de linha de comando (CLI). Abaixo, exploramos a 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 Funcionalidades

  • 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 comando (CLI) para operações rápidas.
  • Processamento em Lote: Forte suporte para processamento em lote via linha de comando rica, tornando-o 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 com 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 Comando

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 será 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() {
    // Crie um novo documento PDF
    doc := pdfcpu.NewPDF(0, 0)
    defer doc.Close()

    // Adicione uma página ao documento
    page := doc.AddPage()
    page.SetMediaBox(pdfcpu.MediaBox{
        LLX: 0,
        LLY: 0,
        URX: 612,
        URY: 792,
    })

    // Adicione texto à página
    content := "Hello, World!"
    font := pdfcpu.NewFont("Helvetica", "")
    page.AddText(content, font, 12, 100, 750)

    // Salve o documento
    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 focada no design (semelhante ao Bootstrap).
  • Inspirado no Bootstrap; projetado para ser fácil de usar com um estilo declarativo semelhante a HTML/CSS.
  • Construído sobre o gofpdf, simplifica o processo de criação mantendo opções poderosas de personalização.

O Maroto é outra biblioteca Go para criar PDFs, mas foca em simplificar o processo abstraindo detalhes de baixo nível. Ele se baseia na biblioteca gofpdf e fornece uma API mais amigável para gerar documentos.

Exemplo de Uso do Maroto

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

package main

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

func main() {
    // Crie um novo documento PDF com dimensões especificadas
    m := maroto.NewPDF(595, 842) // Tamanho A4 em pontos

    // Adicione algum texto à primeira página
    m.AddText("Hello, Maroto!", 0, 0)

    // Salve o PDF em um arquivo
    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 ele usando o Maroto.

Unipdf

O UniPDF é outra biblioteca poderosa e abrangente para criar e processar arquivos PDF em Golang (Go). Oferece uma ampla gama de recursos que o 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, script).
  • Biblioteca poderosa para criar e processar PDFs (Go puro).
  • Oferece recursos extensos, incluindo elementos interativos como links, marcadores, mesclagem/divisão, criptografia e muito mais.
  • API abrangente para leitura e escrita de objetos PDF (dicionários, streams).
  • Adequado para aplicações que necessitam de capacidades robustas de geração de PDF.

Instalação do UniPDF

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

# Crie um Novo Diretório:
mkdir go-pdf-generator cd go-pdf-generator
# Inicialize o Módulo Go:
go mod init go-pdf-generator
# Instale a Biblioteca UniPDF:
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 o UniPDF:

package main

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

func main() {
    // Crie um novo documento PDF
    pdf := creator.New()

    // Adicione uma página ao PDF
    page := pdf.NewPage()

    // Configure o stream de conteúdo para a página
    contentStream := model.NewContentStream()
    page.SetContents(contentStream)

    // Adicione texto à página
    text := "Hello, UniPDF!"
    font := creator.NewStandardFont(creator.FontHelvetica)
    textObject := model.NewText(text, font, 12)
    contentStream.Add(textObject)

    // Salve o documento PDF
    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 nele. O arquivo resultante example.pdf conterá o texto “Hello, UniPDF!”.

Wrapper wkhtmltopdf

Recursos:

  • Converte templates HTML (renderizados com html/template do Go) para PDF.
  • Margens, orientação de página e cabeçalhos/rodapés personalizáveis.
  • Adequado quando o design do documento é complexo e envolve estilização HTML/CSS.
  • Usa 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 comando para várias 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 do pdflib

A biblioteca pdflib foi projetada para ser um processador de PDF abrangente para a linguagem de programação Go. Suporta várias funcionalidades, como validar, otimizar, dividir, mesclar, extrair conteúdo de e recortar PDFs. A biblioteca adere ao padrão PDF 32000-1:2008 (PDF 1.7), garantindo compatibilidade com uma ampla gama de documentos PDF.

Funcionalidades Principais

  • 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 de múltiplas páginas em PDFs de página única ou mesclar vários PDFs em um.
  • 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 o pdflib, você precisa instalá-lo via 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 demonstrando como usar a biblioteca pdflib para realizar operações básicas de PDF:

Para validar um PDF contra o padrão PDF 1.7, você pode usar o seguinte código:

package main

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

func main() {
   // Valide um arquivo PDF
   err := pdflib.Validate("example.pdf")
   if err != nil {
     fmt.Println("Validação falhou:", err)
   } else {
     fmt.Println("PDF é válido.")
   }
}

Conclusão

Para gerar 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 HTML complexo e estilização.
  • Processamento Avançado de PDF: Opte por Unipdf ou pdfcpu quando sua aplicação 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 PDF, proporcionando aos desenvolvedores uma variedade de ferramentas para escolher com base em seus requisitos específicos.