api

package main

import (
	"fmt"

	"bitbucket.org/silviolucasfilho/pdfcpu/pkg/pdfcpu"
)

func main() {
	// Please refer to the following examples.
}

func exampleProcessValidate() {

	config := pdfcpu.NewDefaultConfiguration()

	// Set optional password(s).
	//config.UserPW = "upw"
	//config.OwnerPW = "opw"

	// Set relaxed validation mode.
	config.ValidationMode = pdfcpu.ValidationRelaxed

	_, err := Process(ValidateCommand("in.pdf", config))
	if err != nil {
		return
	}

}

func exampleProcessOptimize() {

	config := pdfcpu.NewDefaultConfiguration()

	// Set optional password(s).
	//config.UserPW = "upw"
	//config.OwnerPW = "opw"

	// Generate optional stats.
	config.StatsFileName = "stats.csv"

	// Configure end of line sequence for writing.
	config.Eol = pdfcpu.EolLF

	_, err := Process(OptimizeCommand("in.pdf", "out.pdf", config))
	if err != nil {
		return
	}

}

func exampleProcessMerge() {

	// Concatenate this sequence of PDF files:
	filenamesIn := []string{"in1.pdf", "in2.pdf", "in3.pdf"}

	_, err := Process(MergeCommand(filenamesIn, "out.pdf", pdfcpu.NewDefaultConfiguration()))
	if err != nil {
		return
	}

}

func exampleProcessSplit() {

	// Split into single-page PDFs.

	config := pdfcpu.NewDefaultConfiguration()

	_, err := Process(SplitCommand("in.pdf", "outDir", 1, config))
	if err != nil {
		return
	}

}

func exampleProcessSplitWithSpan() {

	// Split into PDFs using a split span of 2
	// Each generated file has 2 pages.

	config := pdfcpu.NewDefaultConfiguration()

	_, err := Process(SplitCommand("in.pdf", "outDir", 2, config))
	if err != nil {
		return
	}

}

func exampleProcessTrim() {

	// Trim to first three pages.
	selectedPages := []string{"-3"}

	config := pdfcpu.NewDefaultConfiguration()

	// Set optional password(s).
	//config.UserPW = "upw"
	//config.OwnerPW = "opw"

	_, err := Process(TrimCommand("in.pdf", "out.pdf", selectedPages, config))
	if err != nil {
		return
	}

}

func exampleProcessExtractPages() {

	// Extract single-page PDFs for pages 3, 4 and 5.
	selectedPages := []string{"3..5"}

	config := pdfcpu.NewDefaultConfiguration()

	// Set optional password(s).
	//config.UserPW = "upw"
	//config.OwnerPW = "opw"

	_, err := Process(ExtractPagesCommand("in.pdf", "dirOut", selectedPages, config))
	if err != nil {
		return
	}

}

func exampleProcessExtractImages() {

	// Extract all embedded images for first 5 and last 5 pages but not for page 4.
	selectedPages := []string{"-5", "5-", "!4"}

	config := pdfcpu.NewDefaultConfiguration()

	// Set optional password(s).
	//config.UserPW = "upw"
	//config.OwnerPW = "opw"

	_, err := Process(ExtractImagesCommand("in.pdf", "dirOut", selectedPages, config))
	if err != nil {
		return
	}

}

func exampleProcessListAttachments() {

	config := pdfcpu.NewDefaultConfiguration()

	// Set optional password(s).
	//config.UserPW = "upw"
	//config.OwnerPW = opw"

	list, err := Process(ListAttachmentsCommand("in.pdf", config))
	if err != nil {
		return
	}

	// Print attachment list.
	for _, l := range list {
		fmt.Println(l)
	}

}

func exampleProcessAddAttachments() {

	config := pdfcpu.NewDefaultConfiguration()

	// Set optional password(s).
	//config.UserPW = "upw"
	//config.OwnerPW = "opw"

	_, err := Process(AddAttachmentsCommand("in.pdf", []string{"a.csv", "b.jpg", "c.pdf"}, config))
	if err != nil {
		return
	}
}

func exampleProcessRemoveAttachments() {

	config := pdfcpu.NewDefaultConfiguration()

	// Set optional password(s).
	//config.UserPW = "upw"
	//config.OwnerPW = "opw"

	// Not to be confused with the ExtractAttachmentsCommand!

	// Remove all attachments.
	_, err := Process(RemoveAttachmentsCommand("in.pdf", nil, config))
	if err != nil {
		return
	}

	// Remove specific attachments.
	_, err = Process(RemoveAttachmentsCommand("in.pdf", []string{"a.csv", "b.jpg"}, config))
	if err != nil {
		return
	}

}

func exampleProcessExtractAttachments() {

	config := pdfcpu.NewDefaultConfiguration()

	// Set optional password(s).
	//config.UserPW = "upw"
	//config.OwnerPW = "opw"

	// Extract all attachments.
	_, err := Process(ExtractAttachmentsCommand("in.pdf", "dirOut", nil, config))
	if err != nil {
		return
	}

	// Extract specific attachments.
	_, err = Process(ExtractAttachmentsCommand("in.pdf", "dirOut", []string{"a.csv", "b.pdf"}, config))
	if err != nil {
		return
	}
}

func exampleProcessEncrypt() {

	config := pdfcpu.NewDefaultConfiguration()

	config.UserPW = "upw"
	config.OwnerPW = "opw"

	_, err := Process(EncryptCommand("in.pdf", "out.pdf", config))
	if err != nil {
		return
	}
}

func exampleProcessDecrypt() {

	config := pdfcpu.NewDefaultConfiguration()

	config.UserPW = "upw"
	config.OwnerPW = "opw"

	_, err := Process(DecryptCommand("in.pdf", "out.pdf", config))
	if err != nil {
		return
	}
}

func exampleProcessChangeUserPW() {

	config := pdfcpu.NewDefaultConfiguration()

	// Provide existing owner pw like so
	config.OwnerPW = "opw"

	pwOld := "pwOld"
	pwNew := "pwNew"

	_, err := Process(ChangeUserPWCommand("in.pdf", "out.pdf", config, &pwOld, &pwNew))
	if err != nil {
		return
	}
}

func exampleProcessChangeOwnerPW() {

	config := pdfcpu.NewDefaultConfiguration()

	// Provide existing user pw like so
	config.UserPW = "upw"

	// old and new owner pw
	pwOld := "pwOld"
	pwNew := "pwNew"

	_, err := Process(ChangeOwnerPWCommand("in.pdf", "out.pdf", config, &pwOld, &pwNew))
	if err != nil {
		return
	}
}

func exampleProcesslistPermissions() {

	config := pdfcpu.NewDefaultConfiguration()
	config.UserPW = "upw"
	config.OwnerPW = "opw"

	list, err := Process(ListPermissionsCommand("in.pdf", config))
	if err != nil {
		return
	}

	// Print permissions list.
	for _, l := range list {
		fmt.Println(l)
	}
}

func exampleProcessAddPermissions() {

	config := pdfcpu.NewDefaultConfiguration()
	config.UserPW = "upw"
	config.OwnerPW = "opw"

	config.UserAccessPermissions = pdfcpu.PermissionsAll

	_, err := Process(AddPermissionsCommand("in.pdf", config))
	if err != nil {
		return
	}

}

func exampleProcessStamp() {

	// Stamp all but the first page.
	selectedPages := []string{"odd,!1"}
	var watermark *pdfcpu.Watermark

	config := pdfcpu.NewDefaultConfiguration()
	// Set optional password(s).
	//config.UserPW = "upw"
	//config.OwnerPW = "opw"

	_, err := Process(AddWatermarksCommand("in.pdf", "out.pdf", selectedPages, watermark, config))
	if err != nil {
		return
	}

}

func exampleProcessWatermark() {

	// Stamp all but the first page.
	selectedPages := []string{"even"}
	var watermark *pdfcpu.Watermark

	config := pdfcpu.NewDefaultConfiguration()
	// Set optional password(s).
	//config.UserPW = "upw"
	//config.OwnerPW = "opw"

	_, err := Process(AddWatermarksCommand("in.pdf", "out.pdf", selectedPages, watermark, config))
	if err != nil {
		return
	}

}

Output:

// This example shows calling into the API with ReadSeeker/Writer.

// This allows to run pdf as a backend to an http server for on the fly pdf processing.

config := pdf.NewDefaultConfiguration()
config.Cmd = pdf.OPTIMIZE

fileIn := filepath.Join(inDir, "CenterOfWhy.pdf")
fileOut := filepath.Join(outDir, "test.pdf")

rs, err := os.Open(fileIn)
if err != nil {
	return
}

defer func() {
	rs.Close()
}()

fileInfo, err := rs.Stat()
if err != nil {
	return
}

ctx, err := ReadContext(rs, fileIn, fileInfo.Size(), config)
if err != nil {
	return
}

err = ValidateContext(ctx)
if err != nil {
	return
}

err = OptimizeContext(ctx)
if err != nil {
	return
}

w, err := os.Create(fileOut)
if err != nil {
	return
}

defer func() {

	// The underlying bufio.Writer has already been flushed.

	// Processing error takes precedence.
	if err != nil {
		w.Close()
		return
	}

	// Do not miss out on closing errors.
	err = w.Close()

}()

err = WriteContext(ctx, w)
if err != nil {
	return
}

Output: