Skip to content

Language basics

Content Script is a Domain-Specific Programming Language (DSL) for OpenText Content Server.

The language is based on Oscript and exposes a Groovy interface to developers. Groovy ( ) is a widespread dynamic language for the Java Virtual Machine, particularly indicated for the creation of DSLs.

Content Script language syntax is fully compatible with Groovy.

Under the hood, a mix of Oscript and Java features allow for a deep integration with Content Server functionalities, as well as for an extreme ease of integration with external systems.

The following sections are meant to be an introduction to the language.


The definition of variables can be either generic or restricted to a specific type. Assigning a value to a variable that does not match its type will force the engine to attempt to cast its value to the given type. In case no conversions can be done, it will result in an error.

// Defining a local variable can be done either by 
// 1) declaring explicitly its type     
// 2) using the "def"
int anInt = 1

String aString = "text"

def anObject = "anything"
anObject = 123

With String variables, a few useful tricks are available:

// Strings can be defined both with quotes ('') or double quotes ("")
String aString = "text"
String anotherString = 'text'

// Selecting the alternative "" or '' can be useful if quotes are present in the string content
String aQuote = "this is a quote: 'My words...' "
String anotherQuote = 'this is a quote: "My words..." '

// using triple """ allows to span across multiple lines for string
// definition. Useful for readable SQL queries, for example..
String multilineString = """SELECT *
                            FROM DTREE
                            WHERE DATAID = 2000"""

Lists and Maps can be defined very easily
def aList = ["firstElement", "secondElement"]

def aMap = [firstKey:"firstValue", secondKey:"secondValue"]

// statements can span across multiple lines
def multilineDefinition = ["firstElement",

// collections can contain different kinds of elements
def aMapWithStringsAndInts = [first:"one", second:2

Basic Control Structures

Below are the basic structures for flow control and iteration

  • if – else statement

  • if – else if – else statement

  • inline if statement

  • switch statement

  • while loop

  • for loop

Flow control: if – else

if(a == b){
    //do something
} else {
    //do something else

Flow control: if - else if - else

if(a == b){
    // do the first thing
} else if(c == d){
    // do a second thing
} else {
    // do something else

Flow control: inline if - else

a = (b == c) ? "c is equal to b" : "c is different from b"

Flow control: switch

switch ( a ) {
    case "a":
        result = "string value"

    case [1, 2, 3, 'b', 'c']:
        result = "a mixed list of elements"

    case 1..10:
        result = "a range"

    case Integer:
        result = "is an Integer"

    case Number:
        result = "is a Number"

        result = "default"

Looping: while

def a = 0

while (a++ < 10){
    // do something ten times

def b = 10

while ( b-- > 0 ) {
   // do something ten times

Looping: for

// Standard Java loop
for (int i = 0; i < 5; i++) {


// range loop
for ( index in 0..100 ) {
    // do something

// list or array loop
for ( index in [0, 10, 20, 40, 100] ) {
    // do something 5 times

// map looping
def aMap = ['first':1, 'second':2, 'third':3]

for ( entry in aMap ) {
    // do something for each entry (the values can be accessed and used)


All Groovy operators can be used in Content Scripts:

Operator Name Symbol Description
Spaceship <=> Useful in comparisons, returns -1 if left is smaller 0 if == to right or 1 if greater than the right
Regex find =~ Find with a regular expression
Regex match ==~ Get a match via a regex
Java Field Override .@ Can be used to override generated properties to provide access to a field
Spread *. Used to invoke an action on all items of an aggregate object
Spread Java Field *.@ Combination of the above two
Method Reference .& Get a reference to a method, can be useful for creating closures from methods
asType Operator as Used for groovy casting, coercing one type to another.
Membership Operator in Can be used as replacement for collection.contains()
Identity Operator is Identity check. Since == is overridden in Groovy with the meaning of equality we need some fallback to check for object identity.
Safe Navigation ?. returns nulls instead of throwing NullPointerExceptions
Elvis Operator ?: Shorter ternary operator

Methods and Service Parameters

Methods on objects can be called using the dot "." followed by the method signature and parameter clause.

out << template.evaluateTemplate("""
#@csform(false, "Submit")
    <label for="myFile">File to be uploaded</label>
    <input type="file" name="myFile"  />

if(params.myFile && params.myFile.filelength){
    def parentNode = docman.createFolder("MyFolder")
    def file = new File(params.myFile)
    if(file && file.canRead()){
        docman.createDocument( parentNode, params.myFile_filename, file, "", false, parentNode)
        //Redirect after submit
        redirect "${url}/open/${self.ID}"

Methods can be called omitting the parenthesis in the parameter clause, given that (a) there is no ambiguity and (b) the method signature has at least one parameter.

// In certain cases, parenthesis can be omitted
docman.createFolder "MyFolder"

Properties and Fields

Properties and public fields of objects can be accessed using the dot "." followed by the property or field name.

def folder = docman.createFolder("myFolder")

// Accessing an object property
def me = folder.createdBy

A safe syntax to navigate through fields is available in Groovy by adding a "?" before the dot. In this case, the chain will be interrupted if one of the intermediate values is undefined, avoiding an exception to be raised.

// Safe field access (no exception raised if folder is NULL)
def me = folder?.createdBy


// Comments are available as single line // and multiline /* */

def a = 1 // A comment can close a line

/* Or span
over multiple
lines */


Content Script inherits from Groovy the concept of Closures. A closure is an open, anonymous, block of code that can take arguments, return a value and that can be assigned to a variable.

// Define a closure and assign it to a variable
def addNumbers =  {  def num1 , def num2 -> //Arguments
    return (num1 as int)+(num2 as int)

out << "Calling the addNumbers closure:${addNumbers(4, "5")} <br/>"

addNumbers = { String... arguments -> // Variable number of arguments (MUST be the last parameter)
    def total =0
    arguments.each{total+=(it as int)}
    return total

out << "Calling the addNumbers closure:${addNumbers("1", "2","3")} <br/>"

def createNewFolder = {  String name,  def parentNode = docman.getEnterpriseWS() -> 
    docman.createFolder(parentNode, "name" )

def node = createNewFolder( new Date().format("yyyyMMddHHss"))
out << "Calling the createNewFolder with One arguments:${node.ID} <br/>"

def newNode = createNewFolder( new Date().format("yyyyMMddHHss"), node)
out << "Calling the createNewFolder with Two arguments:${newNode.ID} <br/>"

Content Script programming valuable resources

A number of resources can be extremely useful to the Content Script developer at different times. A few of the most important ones are:

Online help

The Content Script Module features an online guide that covers the basic language syntax and functionalities. It also contains quick references to context variables and methods.

Code Snippet Library

When using the Content Script Editor, a library of ready-to-use code snippets is available to bootstrap new scripts without having to start from scratch. The library includes usage examples and code templates for many common use cases, and can be easily extended by the developer.

Groovy reference guide

The Apache Groovy language is supported by a wide community of adopters worldwide. Groovy is supported by the Apache Software Foundation: a significant amount of documentation and examples are available online.

Velocity reference guide

The Apache Velocity engine powers the templating features in Content Script. Velocity is supported by the Apache Software Foundation: lots of documentation and examples can be found throughout the web and on the project’s website.