Document Templates

> Customization > Objects > {object} > Document Templates

Document templates (aka Print Templates) let you generate PDF documents for selected records. You can then download them or view them online.

About Document Templates

Using Document Templates, you merge record data into a formatted document to create a PDF with rich formatting. You can use such templates to create prefilled forms, invoices, contracts, and other types of documents using data stored in your application.

A Document Template can be based on an HTML file, a Word document, a PowerPoint presentation, or a JSP Page stored in the platform. You can use them to print individual records, or to print multiple records displayed in a View.

Note: HTML, Word, and PowerPoint files are created outside of the platform, and then uploaded for use. Once created, they can be downloaded, edited, and uploaded again. JSP Pages are created and edited either in the platform, or using the Eclipse Plug-in.

Examples

Create an Expense Report to be used in expense management application
Print an Employee Benefit Form
Print Invoices for a collection of records selected in a View

Learn more: Sample Document Templates you can customize and use.

Document Template Formats

Document Templates can be created in a variety of formats including:

JSP Pages
HTML pages
Ms Word Documents
PowerPoint Presentations
Compound Templates that are a composite of multiple parts

How Document Templates Work

At bottom, Document templates are formatted documents with variables you create by inserting specific codes. When you generate a PDF, the codes are replaced by record data, images, and charts, to create a customized version of the template.

For even more dynamic documents, the platform uses the Apache Velocity templating engine, which allows you to vary the content of the document based on record data, and to create repeating parts for related records, like the OrderItems in an Order.

Learn more: http://velocity.apache.org/engine/releases/velocity-1.5/user-guide.html

In outline, the process for creating a Document Template looks like this:

You create a document (on your local file system) or an JSP Page in the platform that includes all of the fixed text and images you want to include in your template.
While creating the document, you make note of the platform data you want to add:
- Record fields
- Record images
- Charts created from Reports
- User fields
- Company fields
- Fields from Related Records
You use the Template Variable Tool to get the field names you need to customize the HTML file with fields and images taken from data records.
You use the Reports tool to get the identifiers for charts you want to add.
You use the Velocity scripting language to build logic into the template, changing the content based on data parameters.

Considerations

CSS styles can be embedded into HTML files. External CSS files can also be referenced in the template, if they are first uploaded as Static Resources.
Fixed images can be inserted into Word and PowerPoint files directly.
Fixed images in an HTML file need to be stored somewhere on the web, and accessed using URLS.

Working with Document Templates

Add a Document Template

A Document Template can be added to any object, except for the built-in Users object. It can use a Page stored in the platform, or it can be created using an external HTML, Word, or PowerPoint file. This section outlines the process.

To add a Document Template to an Object:

Click the [New Template] button.
The New Template page appears.
Use the Template Variable Tool to get the names of variables you can use in the template:

Note:
Template variables can be used in HTML, Word, and PowerPoint files. (In Pages stored in the platform, you use standard JSP programming techniques to access platform information, rather than template variables.)
If it does not already exist, create the template.
Follow the instructions below to add images and template variables, depending on the type of template you need to create:
- Create an MS Word Document Template
- Create a PowerPoint Document Template
- Create an HTML Document Template
- Create a JSP Page Document Template
- Create a Compound Document Template, composed of multiple parts
Provide the information in the Template Information section:
Template Title

The template name

Description

Describe the purpose of the template or other information about it.

Ready to Use

The default setting for the template is Yes.

Type
HTML - To upload an HTML, Word, or PowerPoint file stored on your local system.
The [Browse] button appears.

Click it to locate the file to upload.
Page - To use a JSP/HTML Page stored in the platform.
A list of platform Pages is displayed.

(The list does not include pages that have the Include Headers option.)

Choose one of the listed pages.
Click [Save]

Edit a Document Template based on a Platform JSP/HTML Page

Click > Developer Resources > Pages > {page}
Edit the page.
Learn more: Pages
If you need the names of additional variables:
a. Click > Customization > Objects > {object} > Document Templates

b. View the template to access the Template Variable Tool:

Edit a File-Based Document Template

Click the Download link on the template you want to copy to your local system.
Make changes to the template.
If you need the names of additional variables, click the [New Template] button to access the Template Variable Tool:
If the New Template window is open, click [Cancel] to close it and go back to the Templates (record list) view.
Click the Replace link on the template to upload the modified template.

Warning: Be sure to click the right link. The existing template page will be replaced by the new one.

Use a Template to Print a Record

When viewing a record:

In the Actions list, click Print.
Select the Form or Document Template to use for printing.
Choose whether to print in Portrait or Landscape mode
Choose whether to save the resulting document or view it in a new window, online.
Click [Print].

Note:
In essence, a Form is just another kind of template--only it's one that you create with the interactive Form editor. So Forms also appear in the list of print templates.

Insert Images and Template Variables

See the instructions for the kind of template you are creating:

Create a Compound Document Template

It is also possible to create a print template that is a composite of multiple parts.

Learn more: Create a Compound Document Template

Accessing Related Records

In a Custom Object, fields from related records can be added to a Document Template. (That is, records from an Object that has a Lookup to the current object.)

For example, OrderItems has a lookup to Orders, so in a Document Template for Orders, related OrderItems records can be accessed. (In an object Form, related records are typically displayed in a Subform, although they need not be.)

When formatting a record in the current object for printing, those related records and the fields they contain can be processed in a loop.

Finding and Using Related Record Variables

Finding Related-Record Variables

Related Object variables can be found using the Template Variable Tool. Here, the related OrderItems objects are being chosen from the category list:

Here, the Tag Name field is being selected from the Many to Many relationship with the Tags object:

File:TemplateVariableToolRelatedManyToManyObject.png

The object that is directly connected to Orders is Orders_Tags -- a Junction Object that has Lookups to both Orders and Tags. In that object, the Lookup to Tags is called Related to Tags. Within that group, the Tag Name field is listed, along with other fields in the Tags object.

Once selected, the variable name appears in the Variable area:

$Orders_Tags_record.related_to_Tags.tag_name

where:

$Orders_Tags_record is the expected loop variable for the $Orders_Tags Junction Object records
related_to__Tags is the name of the Lookup field in the Junction Object that references a Tags record
tag_name is the field we want to display
The "dot" separator (.) joins each of the segments in the variable name

Processing Related Records in a Loop

Typically, you'll create a table for the related records, define its headings, and then create a row for a single record, putting the related-record variables into the cells of the row. You then enclose that row in a loop, using the #foreach instruction defined by the Velocity templating engine.

Related records are returned in an array, so the loop creates a new table row for each record in the array.

For example (with formatting attributes removed for simplicity):

foreach( $OrderItems_record in $OrderItems )

end

...

Quantity	Product	Unit Price	Amount
$OrderItems_record.item_quantity	$OrderItems_record.related_to_ProductInventory.product_name	$OrderItems_record.item_price	$OrderItems_record.total

</syntaxhighlight>

where:

The <tbody> element is required around the header row.

The Velocity #foreach directive does the looping.

Learn more: http://velocity.apache.org/engine/releases/velocity-1.5/user-guide.html

The looping construct defines $OrderItems_record as a loop variable.
The loop variable iterates over the $OrderItems array.
The $OrderItems array is automatically available in the template, because OrderItems is a Related Object. (All related objects are available. Each is an array.)

Special Considerations for Subform Variables

Totals and additional computation fields defined for a Subform are also available in the Template Variable Tool. To find them, you access the main object (not the object displayed in the Subform), because those fields are added to the object that contains the Subform.

For example, the Subform for OrderItems totals the $Amount column, and then does additional computations on it to add a surcharge. Those values are shown in the $Orders Fields category as Total $Amount and Shipping for $Amount, respectively. (The final total is shown as Net Total $Amount.)

Sample Document Template for an Order Invoice

This sample:

Creates an invoice for an order, showing all items in it
Gets the name and price of order items from the ProductInventory object
Uses Velocity #foreach processing to process OrderItems records for an Order
Uses Velocity #if conditionals to display surcharge and discount rows only if those values are present

div {  
     padding-top: 5px;  
     padding-bottom: 5px;  
     padding-right: 5px;  
     padding-left: 30px;  
     border: 3px;

margin-top: 5%; margin-right: 40%; margin-bottom: 5%; margin-left: 5%;

</style>

</head><body bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">

<img width="100" height="100" src="http://justanothermobilemonday.com/Wordpress/wp-content/uploads/2009/10/android-robot-logo2.jpg" alt="Company logo" /> <---- Company Logo Here
$company.name

$company.street
$company.city, $company.state,
$company.country - $company.zip

(Phone): $user.phone

Order Invoice

Invoice Date: $Orders.date_created

Bill To:
$Orders.account.name - $Orders.account.number
$Orders.account.street
$Orders.account.city, $Orders.account.state,
$Orders.account.country - $Orders.account.zip

(Phone): $Orders.account.phone

Invoice #: $Orders.order_number

foreach( $OrderItems_record in $OrderItems )

end

if( $Orders.grid_surcharge_031f67dd4b3946949df2da276e5c82a6 > 0 )

end

if( $Orders.grid_discount_031f67dd4b3946949df2da276e5c82a6 > 0 )

end

Quantity	Product	Unit Price	Amount
$OrderItems_record.item_quantity	$OrderItems_record.related_to_ProductInventory.product_name	$OrderItems_record.item_price	$OrderItems_record.total
		Sub Total	$Order.grid_comptn_f5631e34b39f4ba39a98559c7215a3b4
		Surcharge	$Orders.grid_surcharge_f5631e34b39f4ba39a98559c7215a3b4
		Discount	$Orders.grid_discount_f5631e34b39f4ba39a98559c7215a3b4
		Tax	$Orders.grid_tax_f5631e34b39f4ba39a98559c7215a3b4
		Shipping	$Orders.grid_shipping_f5631e34b39f4ba39a98559c7215a3b4
		TOTAL AMOUNT DUE	$Orders.grid_net_total_f5631e34b39f4ba39a98559c7215a3b4

Payment Due upon reciept
Thank you for your business!

</body> </html> </syntaxhighlight>

The Subform part of the resulting invoice then looks something like this:

(The Order Invoice template and the Order Invoice sample file are both available in the downloads area.)

Customizing Data Sent to the Template with a Document Template Class

About Document Template Classes

Using a method defined in a Class, you can manipulate the data that a Document Template processes.

How it Works

When a Document Template is processed, it gets its data from the TemplateContext

The TemplateContext contains a HashMap for a record sent to the Document Template. The HashMap contains name/value pairs for the fields in that record. It is retrieved from the context using the Object name (a string).
To a Document Template then, a data object is simply a HashMap that is present in the TemplateContext.

That object is passed to a method you define. By manipulating the HashMaps it contains, you change the data that the Document Template processes. You can even add new "objects", by adding additional HashMaps, and new "related objects", by adding ArrayLists of HashMaps.

HashMaps and ArrayLists can be nested as deeply as needed.

Accessing Values

When you add a simple value to the context, the corresponding template variable is ${keyname}. So if "myParam" is the key, then $myParam inserts the corresponding value into the template.

If you add a HashMap, $myParam.{hashMapKey} accesses the value for some key defined in the map. Ex: $myParam.quantity

If you add an ArrayList, you can process the list in a loop like this:

for ($loopVariable : $myParam) {

 // work with $loopVariable here

} </syntaxhighlight>

If the ArrayList is a list of HashMaps you process the values like this:

for ($loopVariable : $myParam) {

 // work with $loopVariable.{hashMapKey}. Ex: $loopVariable.quantity

} </syntaxhighlight>

Coding a Method in a Document Template Class

In a Document Template, a data reference has the form $objectName.fieldname. To access, create, or modify data in your code, you will do one or more of the following operations:

Retrieve an object's HashMap from the TemplateContext

TemplateContext.get("objectName");

Add or update a data HashMap

TemplateContext.put("objectName", HashMap);

Get a field from a data HashMap

HashMap.get("fieldName");

Add or update a field in a data HashMap

HashMap.put("fieldName",value);
where value is typically a string or a nested HashMap.

Retrieve an ArrayList of HashMaps (one for each related-object record)

TemplateContext.get("RelatedObjectName");

Configuring a Document Template to use a Specified Class and Method

To designate the class and method to use, when creating or editing a Document Template:

Under Custom Data Source, click Enabled.
In Select a Class, choose the class that has the method you want.
In Select Method choose the method that does the processing you want.

The methods available to choose are public methods that have the following signature:

public {void} doSomething(TemplateContext context, String objName, String recordId) { } </syntaxhighlight>

where:

com.platform.api.TemplateContext: Is the container that the Document Template gets its data from.
String (objName): Has the name of the object the Document Template was invoked on.
String (recordID): Has the ID of the record on which it was invoked.

Considerations

Such methods generally return void, but they don't have to. Any method that takes the appropriate arguments is available, regardless of its return value.
A class can contain multiple processing methods, so you can do all template-related work in a single class.
Only one method is run, however. (You select which one.)

Accessing Lookup Target Records

Data from lookup-target records is stored as a nested map. For example, to get data for the template variable $Order.customer.name:

1. HashMap orderMap = TemplateContext.get("Order")

Gets the Order HashMap from the context.

2. HashMap customerMap = orderMap.get("customer")

Gets the lookup-target record for the customer field.

3. String name = customerMap.get("name")

Gets the customer's name.

Accessing Data in Related Records

A Document Template is always invoked on a specific record. Related-object records that look up to that record are contained in an ArrayList of HashMaps, indexed by object name. The code for obtaining and processing that kind of list looks like this:

public void chgData(TemplateContext context, String obj, String record) {

   ArrayList<HashMap<String,Object>> listOfRecords =
       (ArrayList)context.get("SomeObject");
   if (listOfRecords == null) { listOfRecords = new ArrayList(); }
   for (HashMap<String,Object> currRecord : listOfRecords )
   {

// Process the records in this for-each loop

} </syntaxhighlight>

To create an entirely new breed of related "records", create an ArrayList of the appropriate type and add it to the TemplateContext.

Examples

Changing Field Data

This example substitutes the name of the state for its abbreviation, when processing a Customer record:

public void chgData(TemplateContext context, String obj, String record) {

   HashMap customerMap = (HashMap)context.get("Customer");
   String state = customerMap.get("state").toString();
   if ( "CA".equals(state) ) { 
       customerMap.put("state","California"); 
   }

} </syntaxhighlight>

Example: Adding a New Field

This example adds a new "Good Customer" field to the Customer record.

public void addData(TemplateContext context, String obj, String record) {

   HashMap customerMap = (HashMap)context.get("Customer");
   customerMap.put("rating", "Good Customer"); }

} </syntaxhighlight>

After that method has run, the Document Template can use the variable $Customer.rating, just as though that field was defined in the platform object.

Example: Adding a New Object

This code creates a new ProductSupplier "object" (as far as the Document Template is concerned), and adds it to the TenantContext (context).

public void addObj(TemplateContext context, String obj, String record) {

   HashMap<String, Object> productSupplierMap = new HashMap<String, Object>();
   productSupplierMap.put("supplierName", "Stuff R' Us");
   productSupplierMap.put("phone", "408-555-0987");
   context.put("ProductSupplier", productSupplierMap);

} </syntaxhighlight>

After that method has run, the Document Template can use the variable $ProductSupplier.phone, just as though the data had originated in the platform.

Example: Localizing a Comparison Value

Numeric data in the record HashMap is in the format defined by the user's locale (the User Format. To compare against a value specified in the template, either the record value must be converted to Database Format, or the comparison value must be converted to User Format, using the Java Localization Functions.

Here, the order_amount is retrieved from the Order record. That amount could have a format like "4 500,00 €" in the user's locale. This method converts the amount to the Database Format (4500.00) and stores it in the record as db_order_val:

import com.platform.api.*;

public class TemplateConversions {

 public void convertAmount(TemplateContext context, String obj, String record)
 {
   HashMap orderMap = (HashMap)context.get("Order");
   String order_amount = orderMap.get("order_amount");
   String db_order_val = Functions.parseCurrency(order_amount);
   customerMap.put("db_order_val", db_order_val); }
 }

}</syntaxhighlight>

After that method has run, the Document Template can compare values that are in the same format. For example, a "big order" might be one in which the amount is greater than 1000.00. So $db_order_val can be compared against that amount.

Troubleshooting Tips

Velocity syntax errors cause the Velocity process to die.
Not all browsers display an error message when such errors occur. (Firefox does)
If you're seeing what appears to be a "silent failure', try switching browsers.
When the error occurs in a Word or PowerPoint template, it can be difficult to pinpoint the cause of the error.
Converting the template to HTML helps to pinpoint the line that has the problem.
When a Word or PowerPoint template fails, a process instance is left running, with a corrupted document that can't be read. Subsequent attempts to open the document report an error message, and an additional process is left running.
On a PC, the processes can be found and killed from the Task Manager.
Each open process makes a temporary copy of the template, with a name like, "Template.docx (1)".
The existence of those undeletable template copies is a sign that processes have been left running.
When the processes are killed, the template copies disappear.