Data Templates¶

Data templates in Emakin transform data models into various output formats, such as text or HTML. These templates are utilized across different Emakin components, including form controls and email templates. Templates utilize XPath queries embedded within double curly braces {{ and }}.

For instance, given a data model field named "username," a basic template would be:

1

Hello {{ username }}!

If the "username" field contains "Madonna," the rendered output would be:

1

Hello Madonna!

All XML values are inherently treated as strings; therefore, no automatic data type formatting is performed. To format numbers or dates, explicit type conversion or formatting functions are necessary.

Culture Support¶

Data templates are culture-sensitive, adapting formatting based on the specified culture. The culture is typically derived from user preferences, but can be explicitly set. If no culture is specified, the invariant culture is used.

Specifying Culture in Scripting¶

The following JavaScript example demonstrates formatting using a specific culture ('tr-TR' - Turkish):

1
2
3
4
5

var myNode = $Xml.Parse("<Customer><Name>John</Name><BirthDate>2014-01-31T09:00:00+02:00</BirthDate></Customer");
var result = myNode.Format('<p>{{Customer/BirthDate}}</p>', {
    Culture: 'tr-TR'
});
// result : <p>31.1.2014 09:00:00 +02:00</p>

Data Type Formatting¶

Text Formatting¶

Text or string values are rendered without any implicit formatting.

Number Formatting¶

While functions like "Sum" and "Count" return numbers directly, the number() function can be used for explicit type conversion if needed. Number values are formatted according to decimal rules by default.

Examples:

Date Formatting¶

The template system automatically recognizes XML date types formatted as "YYYY-MM-DDTHH:MM:SSTZ." Emakin consistently uses this format for date values in its data model. Dates in other formats are treated as strings.

Examples (assuming MyDate contains 2014-01-31T09:00:00+02:00):

Scripting example¶

1
2
3
4

var myNode = $Xml.Parse("<Customer><Name>John</Name><BirthDate>2014-01-31T09:00:00+02:00</BirthDate></Customer");
var result = myNode.Format('<p>Birth date : {{Customer/BirthDate}}</p>');

// result : <p>Birth date : 01/31/2014 09:00:00 +02:00</p>

Scripting example¶

A way to remove time from date node:

1
2
3
4

$Xml.SetValue('Test/testdate', new DateTimeOffset());  // testdate will be saved to an XML as "2015-11-12T15:27:16.2568549+02:00"
$Xml.SetValue('Test/testdate2', $Xml.Format("{{ format(Test/testdate,'yyyy-MM-dd') }}"));  // testdate2 will be saved to an XML as "2015-12-11"

// result : 2015-12-11

format() Function Options¶

The format() function offers various options for customizing the output. See the table below for details. Note that the available options and their behavior might vary based on the data type.

Conditional Formatting¶

Conditional rendering is achieved using the following syntax:

1
2

if XPathCondition then Template
if XPathCondition then Template else Template

Example:

Basic usage

1

{{ if Customer/Type = 'A' then <div>Important !</div> }}>

Basic usage with else clause

1

{{ if Customer/Type = 'A' then <div>Important !</div> else <div>{{Customer/Name}}</div> }}>

Repeating Templates¶

To apply a template to multiple nodes, use this syntax:

1

ItemXPath => Template

This iterates over each element matching ItemXPath and applies the template.

Example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

{{ SAMPLE REPORT
<h1>{{Customer/Name}}</h1>
<table>
    {{ Rows/Row =>
    <tr>
        <td>{{Date}}</td>
        <td>{{Description}}</td>
    </tr>
    }}
</table> }}

Generates the following output:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

SAMPLE REPORT
<h1>John</h1>
<table>
    <tr>
        <td>2010-01-01</td>
        <td>description</td>
    </tr>
    <tr>
        <td>2015-01-01</td>
        <td>other description</td>
    </tr>
</table>

Repeating with attribute¶

The x-repeat attribute provides an alternative to the => syntax for repeating templates, particularly useful for HTML generation where the => syntax might lead to tag corruption. For example:

1
2
3
4
5
6
7

{{ SAMPLE REPORT
<table>
    <tr x-repeat="Rows/Row">
        <td>{{Date}}</td>
        <td>{{Description}}</td>
    </tr>
</table> }}

This attribute can be used with any element. For example, it can also be used with "li" tag.

1
2
3
4
5
6

{{
<ul>
    <li x-repeat="Rows/Row">
        <span>{{Date}}</span>
    </li>
</ul> }}

Recursive Repeating Templates¶

For recursive repetition, use this syntax:

1

ItemXPath =>> Template

The template is applied recursively to the results of each iteration.

Example:

1
2
3
4
5

{{ <h1>SAMPLE REPORT</h1>
{{ Sections/Section =>>
<h2>{{Name}}</h2>
<p>{{Body}}</p>  }}
}}

result:

1
2
3
4
5

<h1>SAMPLE REPORT</h1>
<h2>My Section</h2>
<p>Section content</p>
<h2>Sub Section</h2>
<p>Child section content</p>

Template Variables¶

Both custom process variables and system properties are available within templates. Client-side and server-side scripts have different variable contexts.

Client-Side Template Variables¶

Available in client-side scripts (e.g., form scripts):

Server-Side Template Variables¶

Available in server-side scripts (e.g., pre/post-work scripts):

Specific Template Variable Contexts¶

Activity Notifications: In addition to server-side variables, activity notifications use:

User Registration: In addition to server-side variables, user registration templates use: