Template Funktionen - Übersicht

isNumber(value)

Beschreibung
Prüft, ob ein Wert eine Zahl ist und von der Funktion ${toNumber(val)} in eine Zahl umgewandelt werden kann.

${isNumber("10.1")?c} 
          
        

true

${isNumber("foo 10.1")?c} 
          
        

false

<#if isNumber(5)>value ist a number<#else>value ist NOT a number</#if> 
          
        

value ist a number

toNumber(value, default (optional), delimiter (optional, default is .))

Beschreibung
Prüft, ob ein Wert eine Zahl ist und gibt sie oder einen vordefinierten Wert aus. Ist der vordefinierten Wert numerisch, wird er als Nummer ausgegeben. Der Dezimaltrenner kann als 3. Parameter übergeben werden (Default ist "."). Mit anderen Worten: Diese Funktion gibt eine Zahl zurück, wenn ${isNumber(Wert)} true liefert.

${toNumber("10 ")} 
          
        

10

${toNumber("10", "0")} 
          
        

10

${toNumber("foo", "0")} 
          
        

0

${toNumber("10000.100")} 
          
        

10000.1

${toNumber("1000,000.100", "0")} 
          
        

0

${toNumber("1000,000100", "0", ",")} 
          
        

1000.0001

random(MinVal, MaxVal)

Beschreibung
Erzeugt eine Zufallszahl. Die Zufallszahl ist Standard-mäßig vom Datentyp double, also eine Zahl mit Dezimalstellen. Um eine Ganzzahl zu erhalten nutzen Sie das Freemarker-Built-in ?floor, um Abzurunden, und die Dezimalstellen wegzuschneiden.

${random(1,10)} 
          
        

random number between 1 and 10

${random()} 
          
        

random number between 0 and 1 (e.g. 0.567885)

${random(100)} 
          
        

random number between 0 and 100 (e.g. 45.57743)

${random(10,100)} 
          
        

random number between 10 and 100 (e.g. 11.35675)

${random()?floor} 
          
        

random integer number between 0 and 1

${random(100)?floor} 
          
        

random integer number between 0 and 100

${random(10,100)?floor} 
          
        

random integer number between 10 and 100

position_of(string, searchStr, ordinal)

Beschreibung
Ermittelt die n-te Position eines Zeichens bzw. Teilstrings innerhalb einer Zeichenkette. Ein Beispiel mit anderen Worten: "An der wievielten Positionen kommt "-" (Bindestrich) zum zweiten mal vor?"

Position of the 2nd occurence of "-" is ${position_of("1-2-3-4", "-",2)} 
          
        

Position of the 2nd occurence of "-" is 3

unescapeHTML(string)

Beschreibung
Ersetzt HTML Entitäten. Das Gegenstück zu escapeHTML.

escapeHTML(string)

Beschreibung
Ersetzt bestimmte Zeichen durch HTML Entitäten.

stripHTMLTags(inputString)

Beschreibung
Diese Funktion entfernt HTML Tags aus Texten. Das wird häufig in Datenfeeds bei der Artikelbeschreibung benötigt. Bisher konnte man das ganze auch über Suchen/Ersetzen mit einem regulären Ausdruck erreichen. Diese Funktion macht das ganze einfacher und komfortabler.

now()

Beschreibung
Liefert die aktuelle Zeit als Timestamp in Millisekunden.

${now()} 
          
        

1417185735245

eanChecksum(ean)

Beschreibung
Berechnet die 13. Stelle (Prüfsumme) einer EAN13.

${eanChecksum("978381582086")!} 
          
        

5

${"978381582086"+eanChecksum("978381582086")!} 
          
        

9783815820865

UUID()

Beschreibung
Erzeugt eine 36-stellige eineindeutige ID, eine sog. UUID.

${UUID()!} 
          
        

z.B. 8e7f2a40-9f12-4d85-b805-ed6864c13fec

parseField(string, fieldType, contentType, delimiter, keyValueDelimiter)

Beschreibung
Spezialfunktion, die hautpsächlich den Anwendungsfall hat, auf Attributwert zuzugreifen, die wie folgt in einer einzelnen Spalte hinterlegt sind: color=red;size=M Häufig trifft man das bei Artikeldaten an, wo Variantenattribute wie Farbe und Größe auf diese Art mit bestimmten Trennzeichen in einer Spalte stehen. Man könnte alternativ mit der ?split Funktion den String zerlegen, aber parseField ist komfortabler. Wenn Sie nur den ersten Parameter angeben, dann wird MAP angenommen wie in parseField("A=0;B=4;C=DE", "MAP", "TEXT", ";", "=")

<#assign myMap = parseField("A=0;B=4;C=DE")>${myMap.at("C")} 
          
        

DE

<#assign myMap = parseField("A=0;B=4;C=DE", "MAP", "TEXT", ";", "=")>${myMap.at("C")} 
          
        

DE

<#assign myMap = parseField("A=0;C=DE")>${myMap.at("A")} 
          
        

0

<#assign myMap = parseField("A=0;C=DE", "MAP", "TEXT", ";", "=")>${myMap.at("A")} 
          
        

0

parseMap(string, keyValueDelimiter, delimiter)

Beschreibung
Liest eine Zeichenkette wie 'A=0;B=4;C=DE' als Key-Value Map ein. Man kann auf die Werte mit Hilfe des Schlüssels zugreifen. Limitierung: Max. Anzahl Schlüssel: 1000, max. Schlüssel-Länge: 255 Zeichen, max. Wert-Länge: 10000 Zeichen.

${parseMap("a=1;b=2").at("a")} 
          
        

1

${parseMap("a=1;b=2")["a"]} 
          
        

1

${parseMap("a=1;b=2").containsKey("A")?string} 
          
        

false

${parseMap("a=1;b=2").containsKeyIgnoreCase("A")?string} 
          
        

true

${parseMap("a=1;b=2").containsKeysOneOf("c","A")?string} 
          
        

false

${parseMap("a=1;b=2").containsKeysOneOfIgnoreCase("c","A","d" )?string} 
          
        

true

${parseMap("a=1;b=2").atFirst("c","a","d" )} 
          
        

1

${parseMap("a=1;b=2").atFirstIgnoreCase("c","A","d" )} 
          
        

1

${parseMap("a=1;b=2").getFirstKey("c","a","d" )} 
          
        

a

${parseMap("a=1;b=2").atFirstIgnoreCase("c","A","d" )} 
          
        

1

${parseMap("a=1;b=2").containsKeysAll("a","B")?string} 
          
        

false

${parseMap("a=1;b=2").containsKeysAllIgnoreCase("a","B")?string} 
          
        

true

${parseMap("a=1;b=2","=")["a"]} 
          
        

1

${parseMap("a=1;b=2","=", ";")["a"]} 
          
        

1

<#list parseMap("a=1;b=2") as key, value>${key} : ${value}<#sep>,</#sep></#list> 
          
        

a : 1,b : 2

urlEncode(inputString, type, delimiter, keyValueDelimiter, paramName)

Beschreibung
Mit der Funktion urlEncode kann man Zeichenketten so aufbereiten, dass man sie in URLs benutzen kann. Sie ersetzt alle Sonderzeichen, die in URLs nicht erlaubt sind entsprechend. Optional: Verwenden Sie als Typ SINGLE, MULTIPLEVALUE oder MAP

${urlEncode("#sonderzeichen und leerzeichen!\"§%&//("!)!} 
          
        

%23sonderzeichen+und+leerzeichen%21%22%C2%A7%25%26%2F%2F%28

${urlEncode("a=foo#&,b=bar#$","MAP",",","=")!} 
          
        

a=foo%23%26&b=bar%23%24

${urlEncode("a=foo#&,b=bar#$","MULTIPLEVALUE",",")!} 
          
        

a%3Dfoo%23%26&b%3Dbar%23%24

urlDecode(inputString, type, delimiter, keyValueDelimiter, paramName)

Beschreibung
decodiert URLs als einfachen string, zeichenseparierte Liste von Strings oder eine MAP von Schlüssel Wert Paaren. Das Gegenstück zu urlEncode

${urlDecode('%23sonderzeichen+und+leerzeichen')!} 
          
        

#sonderzeichen und leerzeichen

datecalc(field, amount)

Beschreibung
Rechnet mit einem Datum, um Zeiten zu addieren oder subtrahieren. Man kann entweder das aktuelle Datum verwenden oder ein Referenzdatum reingeben.Die verwendbaren Felder sind MONTH, DAY, HOUR, MINUTE, SECOND, MILLISECOND.Hinweis: Bei Verwendung eines Referenzdatums kann das Datum als String oder Date-Objekt reingegeben werden z.B. '2015-08-06 10:39' oder .now

${datecalc("2016-02-03", "DAY", 2)?date?string('yyyy-MM-dd')} 
          
        

2016-02-05

${datecalc("HOUR", 1)!?datetime} 
          
        

Add 1 hour to the current time.

${datecalc("DAY", -2)!?datetime} 
          
        

Returns the date of the day before yesterday, related to now.

${datecalc(.now, "DAY", -1)!?datetime} 
          
        

Returns the date of yesterday, related to now.

${datecalc(prop_lastruntime?datetime, "DAY", -2)?string('yyyy-MM-dd HH:mm')} 
          
        

Subtracts 2 days from the date of the last run.

${datecalc("2016-02-03"?datetime("yyyy-MM-dd"), "DAY", -2)?string('yyyy-MM-dd')} 
          
        

2016-02-01

${datecalc("2016-02-03"?datetime("yyyy-MM-dd"), "DAY", "-2")?string('yyyy-MM-dd')} 
          
        

2016-02-01

datediff(field)

Beschreibung
Berechnet die Differenz zwischen einem Start- und End-Datum. Die verwendbaren Felder sind: 'YEAR', 'MONTH', 'DAY', 'HOUR', 'MINUTE', 'SECOND'. Hinweis: Das Start- und End-Datum kann als String oder Date-Objekt angegeben werden z.B. '2015-08-06 10:39' oder '.now' Bei Angabe von "NOW" wird das aktuelle Datum verwendet.

${datediff("2016-02-03", "2016-02-05", "DAY")} 
          
        

2

${datediff("2016-02-03", "NOW", "DAY")} 
          
        

positive number of days until now.

${datediff("NOW", "2016-02-03", "DAY")} 
          
        

negative number of days from now till past.

${datediff("2016-02-01"?datetime("yyyy-MM-dd"), "2016-02-03", "DAY")} 
          
        

2

isDateBetween(referenceDate, startDate, endDate)

Beschreibung
Prüft, ob ein Datum zwischen einem Start- und Enddatum liegt (einschließlich des Startzeitpunkts und ausschließlich des Endzeitpunkts [Start,Ende)). Diese Funktion gibt true oder false zurück.

${isDateBetween("2016-02-04", "2016-02-03", "2016-02-05")?c} 
          
        

true

${isDateBetween("2016-02-01", "2016-02-03", "2016-02-05")?c} 
          
        

false

${isDateBetween("2016-02-01 11:00:00", "2016-02-01 11:00:00", "2016-02-01 12:00:00")?c} 
          
        

true

${isDateBetween("2016-02-01 11:17:30", "2016-02-01 11:00:00", "2016-02-01 11:17:30")?c} 
          
        

false

${isDateBetween(.now, "2016-02-03", "2016-02-05")?c} 
          
        

false

isDateBefore(referenceDate, otherDate)

Beschreibung
Prüft, ob ein Datum vor einem anderen Datum liegt (ausschließlich des Endzeitpunkts). Diese Funktion gibt true oder false zurück.

${isDateBefore("2016-02-04", "2016-02-03")?c} 
          
        

false

${isDateBefore("2016-02-03", "2016-02-04")?c} 
          
        

true

${isDateBefore("2016-02-04 11:17:30", "2016-02-04 11:17:31")?c} 
          
        

true

${isDateBefore("2016-02-04 11:17:30", "2016-02-04 11:17:30")?c} 
          
        

false

${isDateBefore(.now, "2016-02-03")?c} 
          
        

false

isDateAfter(referenceDate, otherDate)

Beschreibung
Prüft, ob ein Datum nach einem anderen Datum liegt (ausschließlich des Startzeitpunkts). Diese Funktion gibt true oder false zurück.

${isDateAfter("2016-02-04", "2016-02-03")?c} 
          
        

true

${isDateAfter("2016-02-03", "2016-02-04")?c} 
          
        

false

${isDateAfter("2016-02-03 11:17:30", "2016-02-03 11:17:29")?c} 
          
        

true

${isDateAfter("2016-02-03 11:17:30", "2016-02-03 11:17:30")?c} 
          
        

false

${isDateAfter(.now, "2016-02-03")?c} 
          
        

true

lastdayofmonth(referenceDate)

Beschreibung
Liefert ein Date Objekt des letzten Tag des Monats bezogen auf das übergebene Referenzdatum. Wird kein Referenzdatum angegeben, wird der aktuelle Zeitpunkt als Referenzdatum genutzt.

${lastdayofmonth("2016-02-03")?date} 
          
        

Feb 29, 2016

${lastdayofmonth("2016-02-15")?date} 
          
        

Feb 29, 2016

${lastdayofmonth("2016-02-03")?date?string("dd.MM.yyyy")} 
          
        

29.02.2016

${lastdayofmonth()?date} 
          
        

gets the last day of month based on today.

firstdayofmonth(referenceDate)

Beschreibung
Liefert ein Date des ersten Tag des Monats bezogen auf das übergebene Referenzdatum. Wird kein Referenzdatum angegeben, wird der aktuelle Zeitpunkt als Referenzdatum genutzt.

${firstdayofmonth("2016-02-03")?date?string('yyyy-MM-dd')} 
          
        

2016-02-01

${firstdayofmonth("2016-02-15")?date} 
          
        

Feb 1, 2016

${firstdayofmonth("2016-02-03")?date?string("dd.MM.yyyy")} 
          
        

01.02.2016

${firstdayofmonth()?date} 
          
        

the first day of the current month

min(list, delimiter(optional))

Beschreibung
Ermittelt das numerische Minimum einer Liste. Die Liste kann als Liste (z.B. [2,3,4]) übergeben werden oder als String mit einem Trenner wie z.B. Komma (z.B. "2,3,4").

${min([2,3,1,4,5])!} 
          
        

1

${min("2,3,1,4,5")!} 
          
        

1

${min("2,3,1,4,5", ",")!} 
          
        

1

max(list, delimiter(optional))

Beschreibung
Ermittelt das numerische Maximum einer Liste. Die Liste kann als Liste (z.B. [2,3,4]) übergeben werden oder als String mit einem Trenner wie z.B. Komma (z.B. "2,3,4").

${max([2,3,1,5,4])!} 
          
        

5

${max("2,3,1,5,4")!} 
          
        

5

${max("2,3,1,5,4", ",")!} 
          
        

5

deduplicate(list, delimiter(optional))

Beschreibung
Gibt eine deduplizierte Liste aus. Die Liste kann als Liste (z.B. [2,3,4]) übergeben werden oder als String mit einem Trenner wie z.B. Komma (z.B. "2,3,4").

${deduplicate([2,3,2,1,1,4,5])!} 
          
        

[2,3,1,4,5]

${deduplicate("2,3,2,1,1,4,5")!} 
          
        

[2,3,1,4,5]

${deduplicate("2,3,2,1,1,4,5", ",")!} 
          
        

[2,3,1,4,5]

intersection(first list, second list, delimiter(optional))

Beschreibung
Gibt die Schnittmenge (in beiden Listen enthaltene Elemente) zweier Listen aus. Die Listen können als Liste (z.B. [2,3,4]) übergeben werden oder als String mit einem Trenner wie z.B. Komma (z.B. "2,3,4").

${intersection([2,3,2,1,1,4,5], [1,2,4,6,7])!} 
          
        

[2,1,4]

${intersection("2,3,2,1,1,4,5", "1,2,4,6,7")!} 
          
        

[2,1,4]

${intersection("2,3,2,1,1,4,5", "1,2,4,6,7", ",")!} 
          
        

[2,1,4]

symmetricdifference(first list, second list, delimiter(optional))

Beschreibung
Gibt die Symmetrische Differenz (umgekehrte Schnittmenge) zweier Listen aus. Die Listen können als Liste (z.B. [2,3,4]) übergeben werden oder als String mit einem Trenner wie z.B. Komma (z.B. "2,3,4").

${symmetricdifference([2,3,2,1,1,4,5], [1,2,4,6,7])!} 
          
        

[3,5,6,7]

${symmetricdifference("2,3,2,1,1,4,5", "1,2,4,6,7")!} 
          
        

[3,5,6,7]

${symmetricdifference("2,3,2,1,1,4,5", "1,2,4,6,7", ",")!} 
          
        

[3,5,6,7]

difference(first list, second list, delimiter(optional))

Beschreibung
Gibt die Differenzmenge (erste Liste ohne in der zweite Liste enthaltenen Elemente) zweier Listen aus. Die Listen können als Liste (z.B. [2,3,4]) übergeben werden oder als String mit einem Trenner wie z.B. Komma (z.B. "2,3,4").

${difference([2,3,2,1,1,4,5], [1,2,4,6,7])!} 
          
        

[3,5]

${difference("2,3,2,1,1,4,5", "1,2,4,6,7")!} 
          
        

[3,5]

${difference("2,3,2,1,1,4,5", "1,2,4,6,7", ",")!} 
          
        

[3,5]

union(first list, second list, delimiter(optional))

Beschreibung
Gibt die Vereinigung (eindeutige Elemente beider Listen) zweier Listen aus. Die Listen können als Liste (z.B. [2,3,4]) übergeben werden oder als String mit einem Trenner wie z.B. Komma (z.B. "2,3,4").

${union([2,3,2,1,1,4,5], [1,2,4,6,7])!} 
          
        

[2,3,1,4,5,6,7]

${union("2,3,2,1,1,4,5", "1,2,4,6,7")!} 
          
        

[2,3,1,4,5,6,7]

${union("2,3,2,1,1,4,5", "1,2,4,6,7", ",")!} 
          
        

[2,3,1,4,5,6,7]

gross(Number, Percent)

Beschreibung
Errechnet zu einem Netto-Preis den Brutto-Preis zu einem gegebenem Steuersatz

${gross("84.03", "19.0")?string["#.00"]} 
          
        

100.00

net(Number, Percent)

Beschreibung
Errechnet zu einem Brutto-Preis den Netto-Preis zu einem gegebenem Steuersatz

${net("100.00", "19.0")?string["#.00"]} 
          
        

84.03

round(Number, Scale, RoundingMode, RoundingValue)

Beschreibung
Rundet einen numerischen Wert auf eine bestimmte Anzahlt Dezimalstellen und einem Rundungsmodus.

<#assign price=99.8490>${round(price,2,"HALF_EVEN")} 
          
        

99.85

<#assign price=99.8490>${round(price,2,"HALF_EVEN", 0.75)} 
          
        

100.75

sha1(inputString)

Beschreibung
Berechnet den SHA1-Hash eines Wertes.

${sha1("myvalue")!} 
          
        

ca5573497d2abb74de46d1935b07724a9ecb4114

sha256(inputString)

Beschreibung
Berechnet den SHA256-Hash eines Wertes

${sha256("myvalue")!} 
          
        

6ad89927638a4f2594ae2572d0a96a49443a5e310a7cb36988977efce46c9a02

sha512(inputString)

Beschreibung
Berechnet den SHA512-Hash eines Wertes

${sha512('myvalue')!} 
          
        

d64bcaecea366f07cfd2e1e411166d003ba812421b6ebe4e35bd66affd621896cef55ffd217ccdd5fca6159cf297c0ed748ed3f644f1c1cef33cfd43f5e914c1

md5(inputString)

Beschreibung
Berechnet die MD5-Checksumme / Hash eines Wertes.

${md5("myvalue")!} 
          
        

d724a7135ce7d2593c25fc5212d4125a

hmacMD5(message, secret, outputType, messageEncoding, secretEncoding, outputEncoding)

Beschreibung
Berechnet den hmacMD5-Hash eines Wertes.

${hmacMD5("Wert", "mein_secret", "hex")!} 
          
        

7e48cf3c84e43c8fc0fec994e7738e23

${hmacMD5("Wert", "mein_secret", "base64")!} 
          
        

fkjPPITkPI/A/smU53OOIw==

${hmacMD5("Wert", "meinsecretßäüö", "hex", "", "ISO-8859-1","")!} 
          
        

9199c688bc0a2eff51bfcca186d8a1f5

hmacSHA1(message, secret, outputType, messageEncoding, secretEncoding, outputEncoding)

Beschreibung
Berechnet den hmacSHA1-Hash eines Wertes.

${hmacSHA1("Wert", "mein_secret", "hex")!} 
          
        

4d6333c9068edb842a0756b853e7f01bbe7d9820

${hmacSHA1("Wert", "mein_secret", "base64")!} 
          
        

TWMzyQaO24QqB1a4U+fwG759mCA=

${hmacSHA1("Wert", "meinsecretßäüö", "base64", "", "ISO-8859-1")!} 
          
        

RGmh63ml8XTXvNz4olRIcTPXSsg=

hmacSHA256(message, secret, outputType, messageEncoding, secretEncoding, outputEncoding)

Beschreibung
Berechnet den hmacSHA256-Hash eines Wertes.

${hmacSHA256("Wert", "mein_secret", "hex")!} 
          
        

6028de046e8d3097425134ad6792545988b46f428b1694e1ee22c450ea2e9058

${hmacSHA256("Wert", "mein_secret", "base64")!} 
          
        

YCjeBG6NMJdCUTStZ5JUWYi0b0KLFpTh7iLEUOoukFg=

${hmacSHA256("Wert", "meinsecretßäüö", "base64", "", "ISO-8859-1")!} 
          
        

Oaop7HN7SG91pbS2w7wh8PtXU6Oq3MzPjZbnKqXBZkk=

hmacSHA512(message, secret, outputType, messageEncoding, secretEncoding, outputEncoding)

Beschreibung
Berechnet den hmacSHA512-Hash eines Wertes.

${hmacSHA512("myvalue", "my_secret", "hex")!} 
          
        

117e26658253a28860ba54187c9036425d612aec96aeb845ef612f2ca7a45fbf89b0820f72be7b039d502c4996691b70917a694b0b4986e26c0b64cd0b9d2b5a

${hmacSHA512("myvalue", "my_secret", "base64")!} 
          
        

EX4mZYJToohgulQYfJA2Ql1hKuyWrrhF72EvLKekX7+JsIIPcr57A51QLEmWaRtwkXppSwtJhuJsC2TNC50rWg==

${hmacSHA512("myvalue", "my_secretßäüö", "base64", "", "ISO-8859-1")!} 
          
        

5z8IixcPeJkUalFH570iizQ5GwzD38ICzuVmAXMZDFtDNEROE6b74YkcGnUYyFhO5MgWo+yO7JH2quoSnwDy8A==

encodeBase64(input, charset)

Beschreibung
Encoded einen String mit Base64. Standard Zeichensatz ist UTF-8

${encodeBase64("Mein toller String")!} 
          
        

TWVpbiB0b2xsZXIgU3RyaW5n

${encodeBase64("Mein toller String mit Großbuchstaben!", "ISO-8859-1")!} 
          
        

TWVpbiB0b2xsZXIgU3RyaW5nIG1pdCBHcm/fYnVjaHN0YWJlbiE=

decodeBase64(input, charset)

Beschreibung
Decodiert einen Base64 string. Standard Zeichensatz ist UTF-8

${decodeBase64("TWVpbiB0b2xsZXIgU3RyaW5n")!} 
          
        

Mein toller String

${decodeBase64("TWVpbiB0b2xsZXIgU3RyaW5nIG1pdCBHcm/fYnVjaHN0YWJlbiE=","ISO-8859-1")!} 
          
        

Mein toller String mit Großbuchstaben!

fileToBase64(file or filelist, filename)

Beschreibung
Wandelt eine Datei in einen BASE64 String. Kann auch mit FILELIST umgehen und eine einzelne Datei anhand des Names selektieren.

<#assign base64img = fileToBase64(FILEOBJECT)/><#if !base64img?startsWith('ERROR') >${base64img}</#if> 
          
        

The base64 String of the FILEOBJECT

<#assign base64img = fileToBase64(FILELIST, "invoice2.pdf")/><#if !base64img?startsWith('ERROR') >${base64img}</#if> 
          
        

The base64 String of invoice2.pdf inside the FILELIST

substring_word(String, Integer)

Beschreibung
kürzt einen anzugebenden String auf eine anzugebende Länge, vermeidet aber, dass Wörter mitten drin abgeschnitten werden. (Das Zeichen an dem gekürzt wird ist ein Leerzeichen)

${substring_word("abcd efgh", 6)!} 
          
        

abcd

hextonumber(hex string)

Beschreibung
Wandelt eine Hexadecimalzahl in eine Ganzzahl um. Unterstützt die Schreibweise mit 0x / # und ohne.

${hextonumber("0x5b3f6601")} 
          
        

1530881537

${hextonumber("#5b3f6601")} 
          
        

1530881537

${hextonumber("5b3f6601")} 
          
        

1530881537

numbertohex(number)

Beschreibung
Wandelt eine Ganzzahl in eine Hexadezimalzahl um.

${numbertohex("1530881537")} 
          
        

5b3f6601

trim(String, String)

Beschreibung
Entfernt Leerzeichen und ggf. Zeilenumbrüche am Anfang und am Ende des Strings je nach Modus.

${trim('    value    ', 'SBE')} 
          
        

value

${trim('    value with spaces and    \nLinebreak', 'SBE')} 
          
        

value with spaces and    
Linebreak

${trim('    value with spaces and    \nLinebreak','SBENL2S')} 
          
        

value with spaces and     Linebreak

${trim('    value with spaces and    \nLinebreak','TBEREL')} 
          
        

value with spaces and
Linebreak

${trim('    value with spaces and    \nLinebreak','SBENL')} 
          
        

value with spaces and    Linebreak

${trim('    value with spaces and    \nLinebreak','TELJ')} 
          
        

value with spaces andLinebreak

getVariable(key, initialValue)

Beschreibung
Funktion, um den Wert einer Variable zu lesen, die durch setVariable(k,v) gesetzt wurde.

Einschränkungen (z.B. funktioniert nur in bestimmten Steps)
[SpreadsheetMapper]

${getVariable('mykey')} 
          
        

value

${getVariable('mykey', 'myInitialValue')} 
          
        

myInitialValue in case no value does exist for the key 'mykey'. Otherwise returns the actual value.

setVariable(key, value)

Beschreibung
Funktion, um eine Variable zu setzen, die dann in den folgenden Spalten und Zeilen wieder verfügbar ist. Verwenden sie die getVariable Funktion um den Wert zu erhalten. Die Anzahl der Schlüssel(key) ist beschränkt auf 1000. Die maximale Länge der Schlüssel(key) ist 255 Zeichen and die maximale Länge der Werte(value) ist 10000 Zeichen.

Einschränkungen (z.B. funktioniert nur in bestimmten Steps)
[SpreadsheetMapper]

${setVariable('key','value')} 
          
        

getVariable(key, initialValue)

Beschreibung
Funktion, um den Wert einer Variable zu lesen, die durch setVariable(k,v) gesetzt wurde.

Einschränkungen (z.B. funktioniert nur in bestimmten Steps)
[APICall]

${getVariable('mykey')} 
          
        

${getVariable('mykey', 'myInitialValue')} 
          
        

myInitialValue in case no value does exist for the key 'mykey'. Otherwise returns the actual value.

incCounter(counterName, increment)

Beschreibung
Funktion, um eine Zählvariable (counter) hochzuzählen.

Einschränkungen (z.B. funktioniert nur in bestimmten Steps)
[APICall]

${incCounter('myCounter')} 
          
        

1

${incCounter('myCounter',5)} 
          
        

5

nextUrl(url)

Beschreibung
Funktion, die am Ende des parsingTemplate platziert wird und die aufzurufende URL für den nächsten Call definiert. Meistens wird diese Funktion zusammen mit der pagination() Funktion benutzt.

Einschränkungen (z.B. funktioniert nur in bestimmten Steps)
[APICall]

${nextUrl( pagination('http://api.example.com/products?page=1', 1, 1000, 100).plusOne('page')! )} 
          
        

would call http://api.example.com/products?page=2 - page parameter will be dynamically replaced. Url can contain more parameters too.

${nextUrl( pagination(initialUrl, json["currentPage"]?number, json["totalCount"]?number, 100 ).plusOne("page")! )} 
          
        

would call http://api.example.com/products?page=2 but with dynamic parameters

${nextUrl('http://api.examplecom/products?page=2')} 
          
        

would call http://api.example.com/products?page=2

pagination(currentUrl, currentPage, totalCount, perPage)

Beschreibung
Helfer-Funktion, um die nächste URL für Pagination zu erzeugen. Das Ergebnis wird meist an die nextUrl() Funktion übergeben z.B. ${nextUrl( pagination(initialUrl, json["currentPage"]?number, json["totalCount"]?number, 500 ).plusOne("pageNumber")! )} Es gibt mehrere Funktionen, die verwendet werden können: plusOne() geht zur nächsten Seite, basierend auf der aktuellen Seite. Sie gibt einen leeren String zurück, wenn currentPage größer als die Gesamtzahl der möglichen Seiten ist, was als automatische Stopp-Bedingung dient. Die Funktion to() kann verwendet werden, um direkt zu einer bestimmten Seite zu gehen, indem der page-parametername überschrieben wird. Wenn die Seite eine Zahl ist, gibt diese Methode auch einen leeren String zurück, wenn die Seite größer ist als die Gesamtzahl der Seiten. Handelt es sich um eine Zeichenkette, wird immer die URL zurückgegeben, wobei der Page-Parametername ersetzt wird.

Einschränkungen (z.B. funktioniert nur in bestimmten Steps)
[APICall]

${pagination(initialUrl, 1, 1000, 100).plusOne('page')} 
          
        

http://api.example.com/products?page=2

${pagination('http://api.example.com/products?page=1', 1, 1000, 100).plusOne('page')} 
          
        

http://api.example.com/products?page=2

${pagination('http://api.example.com/products', 1, 1000, 100).plusOne('page')} 
          
        

http://api.example.com/products?page=2

${pagination(initialUrl).to('page',2)} 
          
        

http://api.example.com/products?page=2

${pagination('http://api.example.com/products?page=1').to('page',2)} 
          
        

http://api.example.com/products?page=2

${pagination('http://api.example.com/products?after_id=abc123').to('after_id','bcd234')} 
          
        

http://api.example.com/products?after_id=bcd234

setVariable(key, value)

Beschreibung
Funktion, um eine Variable zu setzen, die dann in den folgenden Spalten und Zeilen wieder verfügbar ist. Verwenden sie die getVariable Funktion um den Wert zu erhalten. Die Anzahl der Schlüssel(key) ist beschränkt auf 1000. Die maximale Länge der Schlüssel(key) ist 255 Zeichen and die maximale Länge der Werte(value) ist 10000 Zeichen.

Einschränkungen (z.B. funktioniert nur in bestimmten Steps)
[APICall]

${setVariable('key','value')} 
          
        

urlcontentBase64(url, testIfImageExists)

Beschreibung
Wandelt eine URL (z.B. Bild-URL) in einen BASE64 String.

Einschränkungen (z.B. funktioniert nur in bestimmten Steps)
[SpreadsheetURLDownload,APICall,UrlDownload]

<#assign base64img = meta.urlcontentBase64('http://mywebsite.com/myimage.jpg', true)/><#if !base64img?startsWith('ERROR') >${base64img}</#if> 
          
        

The base64 String of the image-URL 

For batchSize > 1 (without the meta. prefix): <#assign base64img = urlcontentBase64('http://mywebsite.com/myimage.jpg', true)/><#if !base64img?startsWith('ERROR') >${base64img}</#if> 
          
        

The base64 String of the image-URL 

selectHTML(expression)

Beschreibung
Selektiert ein bestimmtes HTML-Fragment mit einem CSS-Selektor (ähnlich zu jQuery). Es gibt eine List sog. JSOUP-Objekte zurück (https://jsoup.org/cookbook/extracting-data/attributes-text-html), die das HTML-Fragment repräsentieren und womit man auf HTML-Tags oder Attribute zugreifen kann.

Einschränkungen (z.B. funktioniert nur in bestimmten Steps)
[HTMLParser,HTML2Spreadsheet]

<#assign nodes = selectHTML("a") /><#list nodes as n>${n.text()} : ${n.attr("href")!}</#list> 
          
        

Outputs the text and href-attribute of each link on the webpage.

addColumns(row, node, prefix, options)

Beschreibung
Fügt alle Felder einer JSON Node als Spalten in einer Zeile des Ausgabe-Spreadsheets hinzu. Syntax: ${addColumns(row, node, prefix, options)}

Einschränkungen (z.B. funktioniert nur in bestimmten Steps)
[JSONReader,APICall]

${addColumns(row, node, 'prefix')} 
          
        

add all fields of the node to the row and prefix all columns with 'prefix'

${addColumns(row, node, 'prefix', {'columns':['sku','stock']})} 
          
        

only add two columns sku and stock and prefix them with prefix

${addColumns(row, node, 'prefix', {'columns':['sku','stock'], 'mode':'exclude'})} 
          
        

add all fields 'except' sku and stock of node to the row and prefix all fields with prefix

${addColumns(row, node, 'prefix', {'columns':['sku','stock'], 'mode':'exclude', 'skipEmptyValues':true})} 
          
        

only add two columns sku and stock, but only if their values are not empty.

Arrays: ${addColumns(row, item['tax_lines'], 'tax_lines_')} 
          
        

if item['tax_lines'] is a JsonArray, then a column will be added for each field of the ArrayElement and the values will be concatenated by comma

Arrays: ${addColumns(row, item['tax_lines'], 'tax_lines_', { 'delimiter': '|'})} 
          
        

if item['tax_lines'] is a JsonArray, then a column will be added for each field of the ArrayElement and the values will be concatenated by custom delimited pipe

Arrays: ${addColumns(row, item['tax_lines'], 'tax_lines_', { 'delimiter': '|', 'columns':['price','rate']})} 
          
        

if item['tax_lines'] is a JsonArray, then a column will be added for each field of the ArrayElement and the values will be concatenated by custom delimited pipe. But only columns price and rate will be added.

Arrays: ${addColumns(row, item['tax_lines'], 'tax_lines_', { 'delimiter': '|', 'columns':['price','rate'], 'mode':'exclude'})} 
          
        

if item['tax_lines'] is a JsonArray, then a column will be added for each field of the ArrayElement and the values will be concatenated by custom delimited pipe. But columns price and rate will be excluded.

Arrays: ${addColumns(row, item['tax_lines'], 'tax_lines_', { 'delimiter': '|', 'textqualifier': ''})} 
          
        

if item['tax_lines'] is a JsonArray, then a column will be added for each field of the ArrayElement and the values will be concatenated by custom delimited pipe and each value is also surrounded by quotes (textqualifier)

flattenJson(row, node, prefix)

Beschreibung
Fügt alle Felder einer JSON Node flach als Spalten in einer Zeile des Ausgabe-Spreadsheets hinzu. Syntax: ${flattenJson(row, node)}. Diese Funktion ist ähnlich wie addColumns(), aber einfacher, da Abflachung der json-Struktur automatisch erfolgt.

Einschränkungen (z.B. funktioniert nur in bestimmten Steps)
[JSONReader,APICall]

${flattenJson(row, node)} 
          
        

converts the JSON node to a flat key value map and add all fields to the row

${flattenJson(row, node, 'myprefix_')} 
          
        

add all fields of node to the row and prefix all columns with prefix 'myprefix_'

addColumns(row, node, prefix, options)

Beschreibung
Fügt alle Felder einer XML Node als Spalten in einer Zeile des Ausgabe-Spreadsheets hinzu. Syntax: ${addColumns(row, node, prefix, options)}

Einschränkungen (z.B. funktioniert nur in bestimmten Steps)
[XMLReader]

${addColumns(row, node, 'prefix')} 
          
        

add all fields of node to the row and prefix all fields with prefix

${addColumns(row, node, 'prefix', {'columns':['sku','stock']})} 
          
        

only add two columns sku and stock and prefix them with prefix

${addColumns(row, node, 'prefix', {'columns':['sku','stock'], 'mode':'exclude'})} 
          
        

add all fields 'except' sku and stock of node to the row and prefix all fields with prefix

${addColumns(row, node, 'prefix', {'columns':['sku','stock'], 'mode':'exclude', 'skipEmptyValues':true})} 
          
        

only add two columns sku and stock, but only if their values are not empty.

attr(attributeName, xmlNode)

Beschreibung
Zugriff auf attribute von XML-Nodes. Syntax: ${attr("attributename", xmlnode)} Beispiel: <product category='myCat'> ${attr("category", xmlnode)} Ausgabe: myCat

Einschränkungen (z.B. funktioniert nur in bestimmten Steps)
[XML2Spreadsheet]

${attr('myAttribute', xmlnode)} 
          
        

Returns the value of the attribute with name myAttribute.

emptyToNull(val)

Beschreibung
Gibt den übergebenen Wert zurück oder null, wenn er leer ist. Der Einsatz ist sinnvoll, wenn ein leeres Feld gleichbedeutend mit 'existiert nicht' ist. Diese Funktion ist z.B. in Verbindung mit der toJSON() Funktion praktisch, um leere Felder null zu setzen, und diese dann aus dem JSON zu entfernen.

${emptyToNull('')!'value is empty'} 
          
        

value is empty

${emptyToNull('foo')} 
          
        

foo

Filter and join columns()

Beschreibung
Filtert Spalten mit einem Filter-Ausdruck (INCLUDE, INCLUDE_NOT_EMPTY oder EXCLUDE) und verbindet deren Werte mit einem Trenner. INCLUDE fügt alle Spalten ein, die auf den Filterausdruck passen. INCLUDE_NOT_EMPTY ebenso, jedoch nur für nicht-leere Spalten. EXCLUDE ist das Gegenteil und schließt alle Spalten aus, die auf den Filter passen. Das erste Beispiel verbindet die Spalte 'name' und alle Spalten die mit dem Prefix 'price' beginnen (z.B. price1, price2 usw.).

Einschränkungen (z.B. funktioniert nur in bestimmten Steps)
[SpreadsheetMapper]

${row.getCols().filter("name,price*","INCLUDE").join(",")} 
          
        

Super Shoe XI;129.99

${row.getCols().filter("name,image*","INCLUDE_NOT_EMPTY").join(",")} 
          
        

Name and all image-columns which contain a image-url (are not empty).

${row.cols.filter("price,name,image", "EXCLUDE").join(";")} 
          
        

All columns except price, name and image

Join all columns by a delimiter()

Beschreibung
Verbindet alle Spalten mit einem Trenner. Das Beispiel verbindet alle Spalten mit einem Komma.

Einschränkungen (z.B. funktioniert nur in bestimmten Steps)
[SpreadsheetMapper]

${row.getCols().join(',')} 
          
        

newMap(map)

Beschreibung
Erzeugt ein Map Objekt. Bietet Methoden zum Hinzufügen, Setzen und Entfernen von Feldern. Wird oft in Verbindung mit ${toJSON()} genutzt. Der Grund für diese Funktion ist, dass Freemarker keine Manipulation von Maps erlaubt. Eine mit newMap() erstellte Map, kann allerdings verändert werden. Der Parameter unflatten='separator' versucht, die verschachtelte Map-Struktur anhand des angegebenen Trennzeichens bestmöglich zu ermitteln. Jedes Trennzeichen im Spaltennamen zeigt eine neue Ebene der erzeugten Map an. Wenn eine Liste als Wert angegeben wird, versucht unflatten jeden Listenwert einer neuen Map zuzuordnen (wie die Funktion zipMap()).

${newMap().set('key1','value1').set('key2','value2')['key1']} 
          
        

value1

${newMap({'key1': 'value1', 'key2': 'value2'})['key1']} 
          
        

value1

${newMap({'key1': 'value1', 'key2': 'value2'}).set('key3','value3')['key3']} 
          
        

value3

${newMap({'key1': 'value1', 'key2': emptyToNull('')})['key2']!'key2 is null, because emptyToNull() was used on an empty string value'} 
          
        

key2 is null, because emptyToNull() was used on an empty string value

${newMap({'key1': 'value1', 'key2': 'value2'}).setNonEmpty('key3','')['key3']!"key3 was not set because it was empty"} 
          
        

key3 was not set because it was empty

${newMap({'key1': 'value1', 'key2': 'value2'}).setNonEmpty('key3','','mydefaultIfEmpty')['key3']} 
          
        

mydefaultIfEmpty

${newMap({'key1': 'value1', 'key2': 'value2'}).set('key3','value3').delete('key3')['key3']!'key3 does not exist anymore'} 
          
        

key3 does not exist anymore

${toJSON(newMap({'node1_key1': 'value1', 'node1_key2': 'value2', 'node2_key3': 'value3', 'node2_key4': 'value4'}).unflatten('_'), {'pretty': true})} 
          
        

{
  "node1" : {
    "key1" : "value1",
    "key2" : "value2"
  },
  "node2" : {
    "key3" : "value3",
    "key4" : "value4"
  }
}

${toJSON(newMap({'key': 'value', 'foo.bar' : '1'}).unflatten('.'), {'pretty': true})} 
          
        

{
  "key" : "value",
  "foo" : {
    "bar" : "1"
  }
}

${toJSON(newMap({'key0': 'value0','node1_key1': [1,2,3], 'node1_key2': [4,5,6], 'node1_key3': [7,8,9], 'node2_key1': 'value1', 'node2_key2': 'value2'}).unflatten('_'), {'pretty': true})} 
          
        

{
  "key0" : "value0",
  "node1" : [ {
    "key1" : 1,
    "key2" : 4,
    "key3" : 7
  }, {
    "key1" : 2,
    "key2" : 5,
    "key3" : 8
  }, {
    "key1" : 3,
    "key2" : 6,
    "key3" : 9
  } ],
  "node2" : {
    "key1" : "value1",
    "key2" : "value2"
  }
}

${toJSON(newMap({'node1[]_key1': 1, 'node1[]_key2': 2, 'node1[]_key3': 3, 'node2_key1[]': 'value1'}).unflatten('_'), {'pretty': true})} 
          
        

{
  "node1" : [ {
    "key1" : 1,
    "key2" : 2,
    "key3" : 3
  } ],
  "node2" : {
    "key1" : [ "value1" ]
  }
}

${toJSON(newMap({'key0': 'value0', 'identifier': 'foo', 'datastoretags': 'bar', 'key1': 'value1'}).deleteReservedCols(), {'pretty': true})} 
          
        

{
  "key0" : "value0",
  "key1" : "value1"
}

${toJSON(newMap({'key0': 'value0', 'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}).delete(['key2', 'key3']), {'pretty': true})} 
          
        

{
  "key0" : "value0",
  "key1" : "value1"
}

parseJSON(json)

Beschreibung
Liest einen Zeichenkette (String) in ein JSON Model.

${parseJSON("{'firstname': 'Max'}")['firstname']!} 
          
        

Max

<#list parseJSON("[{'firstname': 'Max'}, {'firstname': 'Moritz'}]") as person>${person['firstname']}<#sep>,<#sep></#list> 
          
        

Max,Moritz

${parseJSON("[{'firstname': 'Max'}, {'firstname': 'Moritz'}]")?size} 
          
        

2

${parseJSON("[{'firstname': 'Max'}, {'firstname': 'Moritz'}]")[1]['firstname']} 
          
        

Moritz

parseXml(xml)

Beschreibung
Liest einen XML-Zeichenkette (String) in ein XML Model.

${parseXml('<firstname>Max</firstname>')['firstname']!} 
          
        

Max

toJSON(object, config)

Beschreibung
Erstellt einen JSON String aus einem Map oder List Objekt. Wird in Kombination mit der newMap() Funktion genutzt. Der Vorteil im Gegensatz zum manuellen JSON-'zusammenbauen' ist, dass das JSON valide und typsicher ist (d.h. kein Komma zu viel, kein Hochkomma an der falschen Stelle).

${toJSON(newMap({'key': 'value'}))} 
          
        

{"key":"value"}

${toJSON(newMap({'key': 'value'}), {'pretty':true})} 
          
        

{
  "key" : "value"
}

${toJSON(newMap({'key': 'value', 'key2': null, 'key3': '', 'key4': []}), {'removeNull': true})} 
          
        

{"key":"value","key3":"","key4":[]}

${toJSON(newMap({'key': 'value', 'key2': null, 'key3': 'value3'}), {'pretty':true, 'removeNull': true})} 
          
        

{
  "key" : "value",
  "key3" : "value3"
}

${toJSON(newMap({'key': 'value', 'key2': emptyToNull(''), 'key3': 'value3'}), {'pretty':true, 'removeNull': true})} 
          
        

{
  "key" : "value",
  "key3" : "value3"
}

${toJSON(newMap({
    "id": "123",
    "total": 123.99,
    "paid": true,
    "items" : [1,2]?map(i -> newMap({
            "itemid": i
        }))
})
.set("description","foo bar"))
} 
          
        

{"id":"123","total":123.99,"paid":true,"items":[{"itemid":1},{"itemid":2}],"description":"foo bar"}

<#compress><#assign m =
newMap({
    "id": "123",
    "total": 123.99,
    "qty": 1,
    "items" : []
})
.set("description","foo bar")
>

<#assign silent>
${m["items"].add(newMap({"itemId": 1}))}
${m["items"].add(newMap({"itemId": 2}))}
</#assign>

${m.delete("description")}

${toJSON(m)}</#compress> 
          
        

{"id":"123","total":123.99,"qty":1,"items":[{"itemId":1},{"itemId":2}]}

${toJSON([newMap({'key': 'value1'}), newMap({'key': 'value2'})])} 
          
        

[{"key":"value1"},{"key":"value2"}]

${toJSON(newMap({
    "id": "123",
    "total": 123.99,
    "paid": "",
    "items": []
}), {'removeEmpty': true})
} 
          
        

{"id":"123","total":123.99}

zipMap(object, config)

Beschreibung
Erstellt eine Liste, bestehend aus mehreren Maps. Die Eingabe Map besteht aus keys, denen Listen aus Werten oder Einzelwerten zugeordnet sind. Ist die key Zuweisung der Eingabe Map eine Liste, werden die Werte Index basiert in jeweils neue Maps geschrieben. ist die key Zuweisung ein Einzelwert, wird dieser Wert konstant in jeder Map gesetzt.

${toJSON(zipMap({'id':[1,2], 'value': ['foo','bar']}), {'pretty': true})} 
          
        

[ {
  "id" : 1,
  "value" : "foo"
}, {
  "id" : 2,
  "value" : "bar"
} ]

${toJSON(zipMap({'id':[1,2,3], 'value': ['foo','bar']}), {'pretty': true})} 
          
        

[ {
  "id" : 1,
  "value" : "foo"
}, {
  "id" : 2,
  "value" : "bar"
}, {
  "id" : 3,
  "value" : null
} ]

${toJSON(zipMap({'id':[1,2,3], 'value': ['foo','bar']},{'defaultNull': 'syn'}), {'pretty': true})} 
          
        

[ {
  "id" : 1,
  "value" : "foo"
}, {
  "id" : 2,
  "value" : "bar"
}, {
  "id" : 3,
  "value" : "syn"
} ]

${toJSON(zipMap({'id':[1,2,3], 'value': 'foo'}), {'pretty': true})} 
          
        

[ {
  "id" : 1,
  "value" : "foo"
}, {
  "id" : 2,
  "value" : "foo"
}, {
  "id" : 3,
  "value" : "foo"
} ]

${toJSON(zipMap({'id':[1,2], 'value': ['foo','bar','syn']},{'skipNull': ['id']}), {'pretty': true})} 
          
        

[ {
  "id" : 1,
  "value" : "foo"
}, {
  "id" : 2,
  "value" : "bar"
} ]

${toJSON(zipMap({'id':[1,2], 'key': [5,6,7], 'value': ['foo']},{'skipNull': ['id'], 'defaultNull': 'syn'}), {'pretty': true})} 
          
        

[ {
  "id" : 1,
  "key" : 5,
  "value" : "foo"
}, {
  "id" : 2,
  "key" : 6,
  "value" : "syn"
} ]

${toJSON(zipMap({'id':[1,2], 'key': [5,6,7], 'value': ['foo']},{'skipNull': ['id','value']}), {'pretty': true})} 
          
        

[ {
  "id" : 1,
  "key" : 5,
  "value" : "foo"
} ]

${toJSON(zipMap({'id':[1,2], 'key': [5,6,7], 'value': ['foo']},{'defaultNull': {'id': 99, 'value': 'bar'}}), {'pretty': true})} 
          
        

[ {
  "id" : 1,
  "key" : 5,
  "value" : "foo"
}, {
  "id" : 2,
  "key" : 6,
  "value" : "bar"
}, {
  "id" : 99,
  "key" : 7,
  "value" : "bar"
} ]

${toJSON(zipMap({'id':[1,2], 'key': [5,6,7], 'value': ['foo']},{'skipNull': ['id'], 'defaultNull': {'id': 99, 'value': 'bar'}}), {'pretty': true})} 
          
        

[ {
  "id" : 1,
  "key" : 5,
  "value" : "foo"
}, {
  "id" : 2,
  "key" : 6,
  "value" : "bar"
} ]

${toJSON(zipMap({'id':[], 'key': [], 'value': []},{'skipEmpty': true}), {'pretty': true})} 
          
        

[ ]