DEV Community: UniDoc ehf.

Watermarking PDF Files in Go

Gunnsteinn Hall — Sat, 19 Jun 2021 12:18:15 +0000

Introduction

Watermarking a PDF file can be useful for security purposes and tracing the origins of a file. Just like a money bill is watermarked to make it more difficult to forge. A visible watermark such as a company logo or text speaks to the viewer and can convey some information, such as:

The text “Confidential” clearly indicates that the file should not be shared
Company logo behind the text clearly indicates the authority and owner of the file.

UniPDF is a powerful PDF library in Golang which enables creating, editing and processing PDF files. Go is a very powerful language when it comes to designing software that needs speed as well as readability.

In this article we will demonstrate how to use UniPDF to add watermarks to PDF files. We will create a Go program that opens PDFs, applies a watermark loaded from an image and writes out the watermarked PDF. This basis can easily be converted to a batch processing application, or a web service.

Outline - The main function

Our program takes in three arguments the input path of the file that has to be watermarked, the image that will be used as watermark and the output file to write to. And then calls the function addWaterMarkImage to add the watermark. The function will be explained later in detail.

func main() {
   if len(os.Args) < 4 {
       fmt.Printf("go run pdf_watermark_image.go input.pdf watermark.jpg output.pdf\n")
       os.Exit(1)
   }
   inputPath := os.Args[1]
   watermarkPath := os.Args[2]
   outputPath := os.Args[3]
   err := addWatermarkImage(inputPath, outputPath, watermarkPath)
   if err != nil {
       fmt.Printf("Error: %v\n", err)
       os.Exit(1)
   }

   fmt.Printf("Complete, see output file: %s\n", outputPath)
}

Input - Loading the input PDF file

So the input file is the file you need the watermark on. It can be a pdf file with as many pages as you want but for the ease of this article we will be using this example of a report card pdf to display. This file was created in our recent blog post about how to create a PDF report card from scratch with the creator package. This method is used to read the input file from the input path; it gives a pdfReader object which can then be worked with to generate watermarks.

 // Read the input pdf file.
 pdfReader, f, err := model.NewPdfReaderFromFile(inputPath, nil)
 if err != nil {
     return err
 }
 defer f.Close()

Input file - PDF report card that we are planning to watermark

Watermark Image - Loading and insertion

For watermark images it is important to use an image that has transparent background (or is white) as using an image with a non-transparent background can cause it to interfere with our original pdf and can distort the output. Here in this part of the code you can see how to read an image and how to set its position and its scale. It is also important to set the opacity depending on the kind of image you are using, as lowering opacity on image that has light colors can cause the colors to diminish.

watermarkImg, err := c.NewImageFromFile(watermarkPath)
if err != nil {
    return err
}
c.AddPage(page)

watermarkImg.ScaleToWidth(c.Context().PageWidth)
watermarkImg.SetPos(0, (c.Context().PageHeight-watermarkImg.Height())/2)
watermarkImg.SetOpacity(0.125)
_ = c.Draw(watermarkImg)

This draws the watermark on top of the content with transparency.

Alternatively, if the background is troublesome, it might make sense to draw the image first, and then the page contents on top of that. This might possibly lead to your watermark being not visible in all cases. Depends a bit on the use case and the importance of the watermark showing.

In this example we will use the unidoc-logo.png as the watermark.

Generating the output watermarked PDF file

So here we are going to talk about the function that does the magic. It creates a new creator object of UniPDF and then reads the input file and input image and iterates over the entire PDF file to watermark it.

To get the number of pages in a PDF file we use this function. This returns pages or errors in case it fails (which should almost never happen and would indicate a significant problem with the file).

numPages, err := pdfReader.GetNumPages()
if err != nil {
    return err
}

This returns numbers of pages on which we can iterate and then write every page one by page and draw our watermarked Image with desired opacity.

for i := 0; i < numPages; i++ {
    pageNum := i + 1

    // Read the page.
    page, err := pdfReader.GetPage(pageNum)
    if err != nil {
        return err
    }

    // Add to creator.
    c.AddPage(page)

    watermarkImg.ScaleToWidth(c.Context().PageWidth)
    watermarkImg.SetPos(0, (c.Context().PageHeight-watermarkImg.Height())/2)
    watermarkImg.SetOpacity(0.125)
    _ = c.Draw(watermarkImg)
}

The output file is then written out as follows. Prior to writing to file, we apply the outline tree and forms from the original PDF to maintain those if they are set.

// Add reader outline tree to the creator.
c.SetOutlineTree(pdfReader.GetOutlineTree())

// Add reader AcroForm to the creator.
c.SetForms(pdfReader.AcroForm)

return c.WriteToFile(outputPath)

The generated output PDF file then looks as follows

Playground Example - Full runnable code for watermarking PDF files##

The following Play snippet contains the full code and files for producing watermarked PDFs. UniDoc Playground link: https://play.unidoc.io/p/ededc48009bfaf76

Conclusion

We have demonstrated how to use golang and UniPDF to conveniently generate watermarked PDFs in a simple fashion.

Same technique can be used to add images to a PDF as we desire. For example we could add a QR code or barcode to PDF pages, or add a sticky footer or header to each page.

This entire example is a part of our PDF processing examples on GitHub and this particular example can be found here.

Generating Dynamic PDF Reports from Given Data: Report Cards

Gunnsteinn Hall — Thu, 03 Jun 2021 10:59:14 +0000

Introduction
It is useful to generate reports in PDF format so as they are not modifiable and can also be printed easily. Here we are going to talk about how to generate reports using UniPDF in the form of tabular data. We will be looking at it through an example of generating Individual report cards for students from a given set of data.

First we will be looking at generating data. Here we will be using structs and populating data manually, but we could easily provide the input data as an Excel XLSX file and use UniOffice to load the data. Perhaps we will add that in the future. Let us know if you are interested.

Then we will look at how UniPDF creates a table and how to insert cells and format the tables and how to insert the relevant data in the cells. After that we will write it all in PDF.

Generating Data
We can use structs to store the data. Here we have defined two structs. One struct to store the marks and subjects and another struct that holds the entire information for the students, like in our example name, marks (which is a struct) and conduct of the students.

type studentReportCardMark struct {
  Subject string
  Mark int
}

type studentReportCard struct {
  Name string
  Marks []studentReportCardMark
  Punctual rune
  Attentive rune
  Orderly rune
  Polite rune
}

We have made sample data for four students to generate our report cards. For example we will show one here.

var reportCards = []studentReportCard{
{
 Name: "Mike",
 Marks: []studentReportCardMark{
 {
 Subject: "Chemistry 101",
 Mark: 21,
 },
 {
 Subject: "Physics 101",
 Mark: 13,
 },
 {
 Subject: "English 101",
 Mark: 50,
 },
 {
 Subject: "Science 101",
 Mark: 23,
 },
 {
 Subject: "Biology 101",
 Mark: 26,
 },
 {
 Subject: "Computers 101",
 Mark: 33,
 },
 {
 Subject: "Tech 101",
 Mark: 34,
 },
 {
 Subject: "BioChem 101",
 Mark: 14,
 },
 },
 Punctual: 'C',
 Attentive: 'B',
 Orderly: 'B',
 Polite: 'A',
 }
}

Report Design
To design the entire report card we have used tables from UniPDF. For tables we have defined a map of cellStyles that holds the data for the different types of cells we wanna generate in our tables for this design. It has been implemented via struct that holds the properties for individual cells. This is pretty convenient and easy to add and change styles.

type cellStyle struct {
 ColSpan int
 HAlignment creator.CellHorizontalAlignment
 BackgroundColor creator.Color
 BorderSide creator.CellBorderSide
 BorderStyle creator.CellBorderStyle
 BorderWidth float64
 BorderColor creator.Color
 Indent float64
}

One such example of a cellStyle used in this design is used to write the heading to the left of the cell.

var cellStyles = map[string]cellStyle{
 "heading-left": {
 BackgroundColor: creator.ColorRGBFromHex("#332f3f"),
  HAlignment: creator.CellHorizontalAlignmentLeft,
 BorderColor: creator.ColorWhite,
 BorderSide: creator.CellBorderSideAll,
 BorderStyle: creator.CellBorderStyleSingle,
 BorderWidth: 6,
 }

Similarly the report card has used different cellStyles to generate the cells which are described below.

Header
For the header we have used a table of 1 cell with center aligned position and have used a rectangle to highlight the background of the Report Card Heading. It looks like this.

The code is as follows. And it also includes two lines at the end which were drawn using a newLine function.

// Filled rectangle on top. 
rect := c.NewRectangle(0, 0, creator.PageSizeLetter[0], 120)
rect.SetFillColor(creator.ColorRGBFromHex("#dde4e5"))
rect.SetBorderWidth(0)
c.Draw(rect)

headerStyle := c.NewTextStyle()
headerStyle.FontSize = 50

// Table with 1 column to center the text.
table := c.NewTable(1)
table.SetMargins(0, 0, 20, 0)
drawCell(table, newPara(c, "Report Card", headerStyle), cellStyles["centered"])
c.Draw(table)

// Double line.
line := c.NewLine(0, 120, creator.PageSizeLetter[0], 120)
line.SetLineWidth(5)
c.Draw(line)

line = c.NewLine(0, 123, creator.PageSizeLetter[0], 123)
line.SetLineWidth(1.5)
c.Draw(line)

Generating a Student Description
Similarly using a 3 column table a description was generated for each student using the data that was added in the sample and some generic data for the rest of the columns.

This was done using the drawCell function which was designed to draw individual cells as per our need in the given table.

drawCell(table, newPara(c, "Student Name: "+card.Name, studentInfoStyle), cellStyles["left"])

drawCell(table, newPara(c, "School Year: 2020", studentInfoStyle), cellStyles["left"])

drawCell(table, newPara(c, "Roll No: 320", studentInfoStyle), cellStyles["left"])

drawCell(table, newPara(c, "Date: 14/12/2020", studentInfoStyle), cellStyles["left"])

drawCell(table, newPara(c, "Department: Bachelors of Arts", studentInfoStyle), cellStyles["left"])

The Grade Table with Individual Subject Scores
The Grade Table was generated using the sample data and some functions were used to generate the grades and then add them to the table for individual subjects. The subject is left aligned and the rest of the columns are center aligned.

The code is as follows

for _, mark := range card.Marks {
 drawCell(table, newPara(c, " "+mark.Subject, regularStyle), cellStyles["left-highlighted"])
 s := mark.Mark
 percent := (float64(s) / 50.0) * 100.0
 drawCell(table, newPara(c, fmt.Sprintf("%d", s), regularStyle), cellStyles["centered-highlighted"])
 drawCell(table, newPara(c, fmt.Sprintf("%.0f%%", percent), regularStyle), cellStyles["centered-highlighted"])
 drawCell(table, newPara(c, calcGrade(percent), regularStyle), cellStyles["centered-highlighted"])
}

Grading Scheme and Conduct Column
The rest of the report consists of the grading scheme and the conduct which was again generated using the tables and formatted using the cell Style struct that we defined earlier. The Grading scheme is a one column table that displays how grades were assigned and the conduct is a two column table to define conduct for each student. The alignment of these tables was done with a 12-column alignment grid table where the grade and conduct tables were placed at column column 1 and 8 respectively, spawning 3 and 5 columns each.

 // 12-column table for alignment (grid).
 grid := c.NewTable(12)
 grid.SetMargins(0, 0, 50, 0)

 gradeInfoStyle := c.NewTextStyle()
 gradeInfoStyle.Font = font
 gradeInfoStyle.FontSize = 15

 // Grading system table.
 table = c.NewTable(1)
 drawCell(table, newPara(c, "Grading System:", boldStyle), cellStyles["gradingsys-head"])
 drawCell(table, newPara(c, "\u2022 A > 80%", gradeInfoStyle), cellStyles["gradingsys-row"])
 drawCell(table, newPara(c, "\u2022 B > 70%", gradeInfoStyle), cellStyles["gradingsys-row"])
 drawCell(table, newPara(c, "\u2022 C > 60%", gradeInfoStyle), cellStyles["gradingsys-row"])
 drawCell(table, newPara(c, "\u2022 D > 50%", gradeInfoStyle), cellStyles["gradingsys-row"])
 drawCell(table, newPara(c, "\u2022 F < 50%", gradeInfoStyle), cellStyles["gradingsys-row"])

 grid.MultiColCell(3).SetContent(table)
 grid.SkipCells(4)

 // Conduct table.
 table = c.NewTable(2)
 table.SetColumnWidths(0.6, 0.4)
 drawCell(table, newPara(c, "Conduct:", boldStyle), cellStyles["conduct-head"])
 table.SkipCells(1)
 drawCell(table, newPara(c, "Punctual:", gradeInfoStyle), cellStyles["conduct-key"])
 drawCell(table, newPara(c, string(card.Punctual), gradeInfoStyle), cellStyles["conduct-val"])
 drawCell(table, newPara(c, "Attentive:", gradeInfoStyle), cellStyles["conduct-key"])
 drawCell(table, newPara(c, string(card.Attentive), gradeInfoStyle), cellStyles["conduct-val"])
 drawCell(table, newPara(c, "Orderly:", gradeInfoStyle), cellStyles["conduct-key"])
 drawCell(table, newPara(c, string(card.Orderly), gradeInfoStyle), cellStyles["conduct-val"])
 drawCell(table, newPara(c, "Polite:", gradeInfoStyle), cellStyles["conduct-key"])
 drawCell(table, newPara(c, string(card.Polite), gradeInfoStyle), cellStyles["conduct-val"])

 grid.MultiColCell(5).SetContent(table)

 c.Draw(grid)

Generating the PDF output file
In the end the PDF can be generated by using the WriteToFile function which was used in the generateReports function.

// Write to output file.
if err := c.WriteToFile(card.Name + "_marksheet.pdf"); err != nil {
 log.Fatal(err)
}

The whole function

func generateReports(font, fontBold *model.PdfFont, cards []studentReportCard) error {
 for _, card := range cards {
 // Creating Reports
 c := creator.New()
 c.SetPageMargins(40, 40, 0, 0)

 // Filled rectangle on top.
 rect := c.NewRectangle(0, 0, creator.PageSizeLetter[0], 120)
 rect.SetFillColor(creator.ColorRGBFromHex("#dde4e5"))
 rect.SetBorderWidth(0)
 c.Draw(rect)

  headerStyle := c.NewTextStyle()
 headerStyle.FontSize = 50

 // Table with 1 column to center the text.
 table := c.NewTable(1)
 table.SetMargins(0, 0, 20, 0)
 drawCell(table, newPara(c, "Report Card", headerStyle), cellStyles["centered"])
 c.Draw(table)

 // Double line.
 line := c.NewLine(0, 120, creator.PageSizeLetter[0], 120)
 line.SetLineWidth(5)
 c.Draw(line)

 line = c.NewLine(0, 123, creator.PageSizeLetter[0], 123)
 line.SetLineWidth(1.5)
 c.Draw(line)

 // writing Marks
 writeMarks(c, font, fontBold, card)

 // Line on bottom.
 line = c.NewLine(0, creator.PageSizeLetter[1]-3, creator.PageSizeLetter[0], creator.PageSizeLetter[1]-3)
 line.SetLineWidth(5)
 c.Draw(line)

 line = c.NewLine(0, creator.PageSizeLetter[1], creator.PageSizeLetter[0], creator.PageSizeLetter[1])
 line.SetLineWidth(1.5)
 c.Draw(line)

 // Write to output file.
 if err := c.WriteToFile(card.Name + "_marksheet.pdf"); err != nil {
 log.Fatal(err)
 }
 }
 return nil
}

Final Report
The final Report after drawing all the tables and adding the relevant information looks as follows

Performance
Lastly, we want to check the performance of our report generation. We add to the beginning of our code

func main() {
    start := time.Now()

and at the end of the main function

    end := time.Now()
    fmt.Printf("diff: %v\n", end.Sub(start))
}

This gives us the total time for generating all the 5 reports for 5 students. The result we get is

diff: 36.193497ms

So around 36.2ms, or 7.2ms. This means in one second, we could generate hundreds of reports, or in a web system we could serve PDF reports in real-time with a click of a button.

Playground Example: Full Student Report Card
The full code and output on our Playground where it can be edited and re-generated as desired.

https://play.unidoc.io/p/98b800fa3f735b61

Conclusion
UniPDF can be used to generate professional reports with little effort and easy to learn with superb performance. There are many things that can be done in this way like generating Financial Reports, Public data, Medical Health Records, UniPDF can provide the base for generating a lot of reports in a little time.

Filling and Flattening PDF Forms in Go

Gunnsteinn Hall — Thu, 06 May 2021 23:09:58 +0000

Introduction

PDF forms are a convenient tool for gathering and storing information about your customers, users, or employees. For example, you can collect data from your website and insert it into PDF forms by injecting values from JSON files to create everlasting PDFs, i.e. PDF files that have been flattened and made uneditable.

Go is often called the language of the cloud (for good reason) and enables you to create powerful programs and deploy as a single independent binary for convenient deployment in minimal Docker containers or otherwise. It is perfect for microservices and its blazing speed enables you to beat the rest of the class. Thus by processing PDFs in Go gives you fantastic performance, cloud-native applications, and simplicity, much higher security compared to C-based applications.

You might have applications downloadable as PDF forms from your website that users could fill in and send via email or collect the data through forms on your website. Each application you could store for processing and then create a flattened copy which is essentially the form with the data filled out, but has been flattened where the values have been embedded into the content and become an uneditable part of the document.

The next step would be to flatten the PDF form to ensure the immutability of the information. You can now archive the PDFs for your records and email a copy to your customer, user or employee. This is one use case of how you can fill and flatten PDF forms to smoothen your business processes.

Outline

In this article we will cover the following cases:

Create a fillable PDF form on top of a template PDF
Fill a PDF form programmatically via input data in JSON format
Flatten a filled PDF and create an uneditable output PDF with no forms
Fill and flatten in one step as often required.

Creating a fillable PDF form on top of a simple template PDF file

In many cases you will have your forms already prepared. They might be created using Adobe Acrobat or prepared by your designer in more fancy design software and form fields added on top of that with Adobe Acrobat or other software.

Let's look at what to do if we don't have any form prepared. Let's start by preparing a simple PDF file with MS Word with some fields and export it to PDF. Figure 1 shows the resulting PDF file, where key entries are on the left such as "Full Name" followed by a blank where the value is intended to be entered, etc.

Figure 1: Simple PDF form template with visible fields

This kind of PDF is purely flat, meaning that if you open it in a PDF viewer such as Adobe Reader or any web browser, you can only see the text, not insert any values.

To convert this into a fillable PDF form, we need to add some data to the PDF which indicates what fields are in the document, and where they are (i.e. in PDF space coordinates). We just need to define the coordinates of the rectangles where the input field should be present and then let the annotator package of UniPDF take care of building the fields on your PDF document.

We do this by defining

Name. Each field has a unique name so that it can be referenced directly. The name often indicates what the field represents.

Position (Rect). The bounding box representing the field area denoted by a rectangle in PDF coordinates.

Value. The value of the field (if filled). This varies depending on field type. For example for a checkbox it can be true/false (representing checked/unchecked). A textbox would have the value as a simple string and a choice field (dropdown) would have a selected string from a list of options.

For example:

// textFieldsDef is a list of text fields to add to the form. 
// The Rect field specifies the coordinates of the field.
var textFieldsDef = []struct {
    Name string
    Rect []float64
}{
    {Name: "full_name", Rect: []float64{123.97, 619.02, 343.99, 633.6}},
    {Name: "address_line_1", Rect: []float64{142.86, 596.82, 347.3, 611.4}},
    {Name: "address_line_2", Rect: []float64{143.52, 574.28, 347.96, 588.86}},
    {Name: "age", Rect: []float64{95.15, 551.75, 125.3, 566.33}},
    {Name: "city", Rect: []float64{96.47, 506.35, 168.37, 520.93}},
    {Name: "country", Rect: []float64{114.69, 483.82, 186.59, 498.4}},
}

// checkboxFieldDefs is a list of checkboxes to add to the form.
var checkboxFieldDefs = []struct {
    Name    string
    Rect    []float64
    Checked bool
}{
    {Name: "male", Rect: []float64{113.7, 525.57, 125.96, 540.15}, Checked: true},
    {Name: "female", Rect: []float64{157.44, 525.24, 169.7, 539.82}, Checked: false},
}

// choiceFieldDefs is a list of comboboxes to add to the form with specified options.
var choiceFieldDefs = []struct {
    Name    string
    Rect    []float64
    Options []string
}{
    {
        Name:    "fav_color",
        Rect:    []float64{144.52, 461.61, 243.92, 476.19},
        Options: []string{"Black", "Blue", "Green", "Orange", "Red", "White", "Yellow"},
    },
}

Then we create the fields for each type. For instance, in the case of text fields, we create the TextField and add to the page annotations:

 for _, fdef := range textFieldsDef {
        opt := annotator.TextFieldOptions{}
        textf, err := annotator.NewTextField(page, fdef.Name, fdef.Rect, opt)
 if err != nil {
            panic(err)
        }

        *form.Fields = append(*form.Fields, textf.PdfField)
        page.AddAnnotation(textf.Annotations[0].PdfAnnotation)
    }

The process is similar for the other field types as can be seen in the full Playground code example below.

Finally, the output PDF is written out with

 pdfWriter.SetForms(form)
 return pdfWriter.WriteToFile(outputPath)

and the output PDF file can be seen in Figure 2 below. The full code snippet follows with a Playground example that can be modified and run in our playground. It can be seen that the fields now have inputs where values can be inserted in the Viewer.

Figure 2: PDF form created on top of the template PDF file.

Playground Example - Creating a PDF form

The full Playground example for creating a form on top of a simple PDF template is shown below.

https://play.unidoc.io/p/b1e80f0f92ddfa42

Listing fields in a PDF form

When you receive a PDF application form from the Sales department and are instructed to fill it with customer information from a database, you need to know what fields are in the PDF and how to match it to customer information.

Powerful PDF editors such as Adobe Acrobat can show the field information visually, including the field names and properties such as default font, font size, etc.

It can also be convenient to collect the field information programmatically. When working with field data in UniPDF, it is particularly convenient to express the field information as JSON. In fact, it is straightforward to get the full field information from a PDF with a form. The basic code for this is simply:

fdata, _ := fjson.LoadFromPDFFile("template1_with_form.pdf")
jsonData, _ := fdata.JSON()
fmt.Printf("%s\n", jsonData)

The output for this, for instance on the PDF form shown in Figure 2 is:

[
    {
        "name": "full_name",
        "value": ""
    },
    {
        "name": "address_line_1",
        "value": ""
    },
    {
        "name": "address_line_2",
        "value": ""
    },
    {
        "name": "age",
        "value": ""
    },
    {
        "name": "city",
        "value": ""
    },
    {
        "name": "country",
        "value": ""
    },
    {
        "name": "male",
        "value": "Off",
        "options": [
            "Off",
            "Yes"
        ]
    },
    {
        "name": "female",
        "value": "Off",
        "options": [
            "Off",
            "Yes"
        ]
    },
    {
        "name": "fav_color",
        "value": ""
    }
]

So this gives pretty clear indication on what fields we have and what values we can enter. We will use this below and fill into those fields programmatically and finally flattening the PDF.

The full Playground example for this can be found below where it can be Run and the output seen.

Playground Example - Listing fields in PDF form

https://play.unidoc.io/p/c22768ba4fd68e90

Filling a PDF form

Filling a PDF form involves inserting values into the fields. In an editor, it will look like a person had entered values into the field and saved. The values can still be edited and changed.

For an automated process, where values are collected from the user or a database and injected into the PDF, there is a need to perform filling of values programmatically.

The basic way to insert and write out a filled PDF form is:

// Load the form data to be inserted (key/values) from JSON file.
fdata, _ := fjson.LoadFromJSONFile(`data.json`)

// Load the PDF.
pdfReader, _ := model.NewPdfReaderFromFile(`form.pdf`, nil)

// Options for default appearance of contents.
fieldAppearance := annotator.FieldAppearance{OnlyIfMissing: true, RegenerateTextFields: true}

 // Populate the form data.
pdfReader.AcroForm.FillWithAppearance(fdata, fieldAppearance)

// Write out filled PDF.
pdfWriter, _ := pdfReader.ToWriter(nil)
pdfWriter.WriteToFile("form_filled.pdf")

Note we used FillWithAppearance rather than simply Fill to generate appearance based on the values we are setting. In most cases the default appearance is shown, but most viewers can generate appearances based on the values, if the values are edited. Further things like fonts, can be customized as well.

The output file form_filled.pdf looks as follows afterward (Figure 3). We can clearly see that the values have been filled, but the form is still editable.

Figure 3: Example of filled PDF form (not flattened).

The full example is shared below which can be run in the UniDoc Playground.

Playground Example - Filling fields with values in PDF form

https://play.unidoc.io/p/a332fa2932e3f516

Flattening a filled PDF form

Once a PDF has been filled, it can still be edited when viewing it in a viewer. In many cases it is desirable to finalize or flatten the values such that they become contents, i.e. inherent part of the PDF that cannot be edited easily.

To illustrate this, we will work with the filled PDF form from above (Figure 3) and flatten the contents to an uneditable PDF. Note, in the section below we will show how to fill and flatten in a single step, which is often desirable.

The code for flattening a filled PDF form is:

pdfReader, f, _ := model.NewPdfReaderFromFile(inputPath, nil)
defer f.Close()

// Flatten form.
fieldAppearance := annotator.FieldAppearance{OnlyIfMissing: true, RegenerateTextFields: true}

pdfReader.FlattenFields(true, fieldAppearance)

// Generate a PdfWriter instance from existing PdfReader.
// AcroForm field is no longer needed in the output.
pdfWriter, _ := pdfReader.ToWriter(&model.ReaderToWriterOpts{
    SkipAcroForm: true,
})

// Write the output flattened file.
pdfWriter.WriteToFile(outputPath)

Applying this to the form we filled above (Figure 3), the output is as shown below, where the filled PDF has been flattened (Figure 4). The field appearances have been flattened and are a part of the content and the form/fields are no longer editable. The AcroForm dictionary which normally represents form and fields has been removed also as the information is now only part of the PDF contents like any other parts of the PDF.

Figure 4: Filled PDF has been flattened and values made part of the content.

The full runnable example for flattening a PDF form is shown below Playground example which can be loaded and run in our Playground.

Playground Example - Flattening filled PDF form

https://play.unidoc.io/p/6b04a0779dfa37d3

Filling and Flattening PDF forms in a single step

Above, we have covered the cases of creating, filling and flattening PDF forms separately. A common use case is to fill and flatten in a single step. This is usually desirable in applications where a prepared PDF form is to be filled with external information such as filling in customer information.

Another example of how you can use PDF forms to improve your everyday business operations is by using them to collect and document orders, invoices and other engagement documents.

Manually skimming through the data that you collect using PDF forms would be a time-consuming task, which is an inefficient use of your organizational resources. You can use UniPDF to programmatically sift through the data collected using the forms and clean it, process it, and perform meaningful operations on it.

These steps come after you have collected the data. UniPDF can also help you with the data collection stage. You can use the power of Golang to convert data from any data source to beautifully crafted PDF reports built using UniPDF’s form builder.

Playground Example - Fill and flatten a PDF form

https://play.unidoc.io/p/d142b775efc39cde

Conclusion

You can use UniPDF to build beautifully crafted PDF forms through which you can gather information from your users. These forms can be shared and archived to maintain structured records of sales, queries and other engagement processes.

With the help of UniPDF, this process can be streamlined and you can use the library in many ways to improve the efficiency of your office tasks.

UniDoc is constantly improving its libraries based on customer feedback, if you want a feature included in the library, feel free to open a ticket on UniDoc’s GitHub, where you can also check out a whole repository of examples, built to get you started using UniDoc. You can also contact us through the form on the website.

HTML for PDF reports in Go

Gunnsteinn Hall — Mon, 29 Mar 2021 17:46:04 +0000

As a developer, I sometimes need to create PDF reports for my applications.

Creating those entirely by programming can be cumbersome and every library is a bit different. Finally, getting things to look like the designer wanted can be challenging.

Wouldn't it be nice if we can make it look like the design without spending a ton of time on it?

Designers and frontenders can usually do HTML and CSS, so it makes sense to utilize HTML.

But websites usually don't look great when printed out and are not designed for multiple pages.

We have come up with a solution, which we believe addresses all of the above.

Meet UniHTML combined with UniPDF

UniHTML is a new plugin for UniPDF, one of our flagship libraries at UniDoc.

It is a container-based solution with a Go driver, as per the schematic:

The Docker image is publicly available on Docker Hub.

The UniPDF creator package enables creating flexible PDF reports and invoices. The UniHTML container-based module has a flexible web-rendering engine and in unison with UniPDF this brings together the capability to add full HTML support to UniPDF report generation.

Trying it out

Let's try it out.

Step 1. Create a free metered API key.

This is easy, simply signing up on https://cloud.unidoc.io for an account and creating a metered API key in the UI.

For step-by-step instructions on this, see:

Step 2. Get the UniHTML container running

$ docker run -p 8080:8080 -e UNIDOC_METERED_API_KEY=mymeteredkey unidoccloud/unihtml
Unable to find image 'unidoccloud/unihtml:latest' locally
latest: Pulling from unidoccloud/unihtml
6e640006d1cd: Pull complete
1a3def68b0c4: Pull complete
5b1718db67b4: Pull complete
8d4c41b870b6: Pull complete
b1a4436c2bab: Pull complete
3c3af5a4fff5: Pull complete
29863d0ede88: Pull complete
Digest: sha256:c1c69af194358179d836a648f07f71af07ed0c968938abe3a3e2550e49980728
Status: Downloaded newer image for unidoccloud/unihtml:latest
[INFO]  server.go:173 Listening private API on: :8081
[INFO]  server.go:164 Listening public API on: :8080

Step 3. Running an example.

Inspired by the blog post Creating beautiful HTML tables with CSS we put together the following HTML file to illustrate a PDF report with HTML tables.

sample.html

<html>
<head>
<style>

.styled-table {
    border-collapse: collapse;
    margin: 25px 0;
    font-size: 0.9em;
    font-family: sans-serif;
    min-width: 400px;
    box-shadow: 0 0 20px rgba(0, 0, 0, 0.15);
}

.styled-table thead tr {
    background-color: #009879;
    color: #ffffff;
    text-align: left;
}

.styled-table th,
.styled-table td {
    padding: 12px 15px;
}


.styled-table tbody tr {
    border-bottom: 1px solid #dddddd;
}

.styled-table tbody tr:nth-of-type(even) {
    background-color: #f3f3f3;
}

.styled-table tbody tr:last-of-type {
    border-bottom: 2px solid #009879;
}


.styled-table tbody tr.active-row {
    font-weight: bold;
    color: #009879;
}

</style>
</head>

<table class="styled-table">
    <thead>
        <tr>
            <th>Name</th>
            <th>Points</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>Dom</td>
            <td>6000</td>
        </tr>
        <tr class="active-row">
            <td>Melissa</td>
            <td>5150</td>
        </tr>
        <!-- and so on... -->
    </tbody>
</table>

</html>

example.go

package main

import (
    "fmt"
    "os"

    "github.com/unidoc/unihtml"
    "github.com/unidoc/unipdf/v3/common/license"
    "github.com/unidoc/unipdf/v3/creator"
)

func main() {
    // Set the UniDoc license.
    if err := license.SetMeteredKey("my api key goes here"); err != nil {
        fmt.Printf("Err: setting metered key failed: %v\n", err)
        os.Exit(1)
    }

    // Establish connection with the UniHTML Server.
    if err := unihtml.Connect(":8080"); err != nil {
        fmt.Printf("Err:  Connect failed: %v\n", err)
        os.Exit(1)
    }

    // Get new PDF Creator.
    c := creator.New()

    // AddTOC enables Table of Contents generation.
    c.AddTOC = true

    chapter := c.NewChapter("Points")

    // Read the content of the sample.html file and load it to the conversion.
    htmlDocument, err := unihtml.NewDocument("sample.html")
    if err != nil {
        fmt.Printf("Err: NewDocument failed: %v\n", err)
        os.Exit(1)
    }

    // Draw the html document file in the context of the creator.
    if err = chapter.Add(htmlDocument); err != nil {
        fmt.Printf("Err: Draw failed: %v\n", err)
        os.Exit(1)
    }

    if err = c.Draw(chapter); err != nil {
        fmt.Printf("Err: Draw failed: %v\n", err)
        os.Exit(1)
    }


    // Write the result file to PDF.
    if err = c.WriteToFile("sample.pdf"); err != nil {
        fmt.Printf("Err: %v\n", err)
        os.Exit(1)
    }
}

Results

Running the result:

$ go run example.go

creates sample.pdf which looks like:

We note that we also have the table of contents

and the bookmarks that link to each chapter in the PDF.

Headers and footers can also be created easily.

Conclusion

UniHTML brings the ease of HTML to PDF report creation in UniPDF with a full rendering engine. This will make the process of PDF report generation really easy for teams that already have a HTML design and need to add professional PDF reports, where a plain PDF print-out of a website is not sufficient.