Document generation for Jira enables you to perform common manipulations on sequential data. You can group, sort, and perform other sequential data manipulations in template expressions.

Extention methodExamples and notes

all(Predicate) 

persons.all(p => p.age < 50)

any()

persons.any()

any(Predicate)

persons.any(p => p.name == "John Smith")

average(Selector)

persons.average(p => p.age)
The input selector must return a value of any type that has predefined or user-defined addition and division operators.

concat(IEnumerable)

persons.concat(otherPersons)

An implicit reference conversion must exist between types of items of concatenated enumerations.

contains(Object)

persons.contains(otherPersons.first())

count()

persons.count()

count(Predicate)

persons.count(p => p.age > 30)

distinct()

persons.distinct()

first()

persons.first()

first(Predicate)

persons.first(p => p.age > 30)

firstOrDefault()

persons.firstOrDefault()

firstOrDefault(Predicate)

persons.firstOrDefault(p => p.age > 30)

formatDate

formatDate(issue.created)

will produce May/27/2019    Format can be changed on Configuration page of the app, the Date format setting.

formatDateTimeformatDateTime(issue.created)

will produce May/27/2019 10:18 AM      Format can be changed on Configuration page of the app, the Date time format setting.

groupBy(Selector)

persons.groupBy(p => p.age)

Or

persons.groupBy(
    p => new
    {
        age = p.age,
        count = p.children.Count()
    })
This method returns an enumeration of group objects. Each group has a unique key defined by the input selector and contains items of the source enumeration associated with this key. You can access the key of a group instance using the Key property. You can treat a group itself as an enumeration of items that the group contains.

last()

persons.last()

last(Predicate)

persons.last(p => p.age > 100)

lastOrDefault()

persons.lastOrDefault()

lastOrDefault(Predicate)

persons.lastOrDefault(p => p.age > 100)

max(ComparableSelector)

persons.max(p => p.age)

min(ComparableSelector)

persons.min(p => p.aage)

orderBy(ComparableSelector)

persons.orderBy(p => p.age)

Or

persons.orderBy(p => p.age)
    .thenByDescending(p => p.name)

Or

persons.orderBy(p => p.age)
    .thenByDescending(p => p.name)
    .thenBy(p => p.children.count())

This method returns an enumeration ordered by a single key. To specify additional ordering keys, you can use the following extension methods of an ordered enumeration:

  • thenBy(ComparableSelector)
  • thenByDescending(ComparableSelector)

orderByDescending(ComparableSelector)

persons.orderByDescending(p => p.age)

Or

persons.orderByDescending(p => p.age)
    .thenByDescending(p => p.name)

Or

persons.orderByDescending(p => p.age)
    .thenByDescending(p => p.name)
    .thenBy(p => p.children.count())

See the previous note.

single()

persons.single()

single(Predicate)

persons.single(p => p.name == "John Smith")

singleOrDefault()

persons.singleOrDefault()

singleOrDefault(Predicate)

persons.singleOrDefault(p => p.name == "John Smith")

skip(int)

persons.skip(10)

skipWhile(Predicate)

persons.skipWhile(p => p.age < 21)

sum(Selector)

persons.sum(p => p.children.count())

The input selector must return a value of any type that has a predefined or user-defined addition operator.

take(int)

persons.take(5)

takeWhile(Predicate)

persons.takeWhile(p => p.age < 50)

union(IEnumerable)


persons.union(otherPersons)


An implicit reference conversion must exist between types of items of united enumerations.

where(Predicate)

persons.where(p => p.age > 18)