Page History
In this page, it's explained how to export a property when it has more than a single value such as:
Table of Contents maxLevel 3 minLevel 2
The Document Generator also provides data filtering and sorting directly on the iteration definition. Read the following topics:
Table of Contents maxLevel 1
Issue History
You can iterate a section over all the history entries of an issue. This allows you to create a table that dynamically grows according to the number of changes done.
Exportable Data
Field |
---|
Table of Contents |
---|
Iterating Issue History
Changes to issues are registered in the Issue History, but it is not known in advance how many changes are going to be made. You can iterate a section over all the history entries of an issue. This allows you to create a table that dynamically grows according to the number of changes dene. The notation is:
History Entry
Field | Description | ||||||||
---|---|---|---|---|---|---|---|---|---|
HistoryEntriesCount | Returns the number of changes made. | ||||||||
Author | Returns the user who made the change. | ||||||||
Created | Date of the change | ||||||||
ChangedItemsCout | Returns the number of fields changed in the current change. | ||||||||
ChangedItem |
|
The notation is:
Code Block | ||||
---|---|---|---|---|
| ||||
#{for historyEntries} ${fullname:HistoryEntries[n].Author} made changes ${dateformat("dd-MM-yyyy HH:mm:ss"):HistoryEntries[n].Created} #{for ch=HistoryEntries[n].ChangedItemsCount} Field Name: ${HistoryEntries[n].ChangedItems[ch].Field} Old Value: ${HistoryEntries[n].ChangedItems[ch].From} New Value: ${HistoryEntries[n].ChangedItems[ch].To} #{end} #{end} or #{for h=HistoryEntriesCount} ${fullname:HistoryEntries[h].Author} made changes ${dateformat("dd-MM-yyyy HH:mm:ss"):HistoryEntries[h].Created} #{for ch=HistoryEntries[h].ChangedItemsCount} Field Name: ${HistoryEntries[h].ChangedItems[ch].Field} Old Value: ${HistoryEntries[h].ChangedItems[ch].From} New Value: ${HistoryEntries[h].ChangedItems[ch].To} #{end} #{end} |
...
Issue
...
Links
Because
Info |
---|
We suggest that you use the html function to render the data because almost all content is HTML, e.g., ${html:ActivityEntries[n].Title} |
Below is an example of using the Activity iteration in a Word template:
or
Below is an example of using the Activity iteration in an Excel template:
or
Iterating Issue Links
Because it is not known in advance how many linked issues exist for an issue, you can iterate a section over all the linked issues of an issue. This allows you to create a table that dynamically grows according to the number of existing linked issues. The notation is:
Exportable Data
Field | Links FieldsDescription | |||||||||
---|---|---|---|---|---|---|---|---|---|---|
AppType | The application type of the link | |||||||||
LinkType | The type of the link | |||||||||
Key | The key of the linked issue | |||||||||
Summary | The summary of the linked issue | |||||||||
URL | The URL of the link | |||||||||
Returns the Application Type. The values can be:
| ||||||||||
LinkType | Returns the Link Type. |
Note: When the link you are iterating is of AppTypes External Jira or Confluence, the name is obtained using the Summary property.
The notation is:
Code Block | ||||
---|---|---|---|---|
| ||||
Code Block | ||||
| ||||
#{for links} ${Links[n].AppType} ${Links[n].LinkType} ${Links[n].Key} ${Links[n].Summary} ${Links[n].URL} #{end} or #{for <VariableName>=LinksCount} Content and Linked Issue Mappings. Example: ${Links[VariableName].Field} #{end} |
All fields listed here are available on Links[n] because they represent an issue. In addition, there are two new fields at the Links[n] level:
The image below demonstrates an example of a Word template that iterates over linked issues.
or
The image below demonstrates an example of an Excel template that iterates over linked issues.
or
Issue Comments
Because it is not known in advance how many comments exist for an issue, you can iterate a section over all the comments on an issue. This allows you to create a table that dynamically grows according to the number of existing comments. The notation is:
Comments Fields | Description |
---|---|
Author | The author of the comment |
AuthorFullName | The full name of the author of the comment |
Body | The comment |
Created | The date the comment was posted |
GroupLevel | The group level of the comment |
Code Block | ||||
---|---|---|---|---|
| ||||
#{for comments}
${Comments[n].Author}
${Comments[n].AuthorFullName}
${Comments[n].Body}
${dateformat(" |
...
Returns the Application Type. The values can be:
Application Value | Description |
---|---|
JIRA | Link from the same Jira Instance |
External Jira | Link from the another Jira Instance |
Confluence | Link from a Confluence page |
External | External link |
...
Note: When the link you are iterating is of AppTypes External Jira or Confluence, the name is obtained using the Summary property.
The image below demonstrates an example of a Word template that iterates over linked issues.
or
For a working example of this functionality, check the SampleIterations.docx template in the Template Store.
The image below demonstrates an example of an Excel template that iterates over linked issues.
or
Iterating Issue Comments
Because it is not known in advance how many comments exist for an issue, you can iterate a section over all the comments on an issue. This allows you to create a table that dynamically grows according to the number of existing comments. The notation is:
...
The author of the comment
...
Code Block | ||||
---|---|---|---|---|
| ||||
#{for comments}
${Comments[n].Author}
${Comments[n].AuthorFullName}
${Comments[n].Body}
${dateformat("dd-MM-yyyy HH:mm:ss"):Comments[n].Created}
${Comments[n].GroupLevel}
#{end}
or
#{for <VariableName>=CommentsCount}
Content and Issue Mappings. Example: ${Comments[VariableName].Field}
#{end} |
The image The image below demonstrates an example of a Word template that iterates over issue comments.
or
For a working example of this functionality, check the SampleIterations.docx template in the Template Store.
The image The image below demonstrates an example of an Excel template that iterates over issue comments.
or
Info | ||
---|---|---|
| ||
If you are using Jira Service Desk you can see more information about comments here. |
Iterating Issue Worklogs
Issue Worklogs
Because it is not known in advance how many Because it is not known in advance how many worklogs exist for an issue, you can iterate a section over all the worklogs of an issue. This allow you to create a table that dynamically grows according to the number of existing worklogs. The notation is:
Worklogs Fields | Description |
---|---|
Author | The author of the worklog |
AuthorFullName | The full name of the author of the worklog |
Comment | The comment of the worklog |
Created | The date the worklog was created |
Date Started | The date the worklog was started |
Time Spent | The time spent in seconds |
TimeSpentFormatted | The time spent as displayed on Jira |
BilledHours | The billed hours in seconds (Belongs to Tempo Timesheets plugin) |
BilledHoursFormatted | The billed hours as displayed on Jira (Belongs to Tempo Timesheets plugin) |
Code Block | ||||
---|---|---|---|---|
| ||||
#{for worklogs}
${Worklogs[n].Author}
${Worklogs[n].AuthorFullName}
${Worklogs[n].Comment}
${dateformat("dd-MM-yyyy HH:mm:ss"):Worklogs[n].Created}
${dateformat("dd-MM-yyyy HH:mm:ss"):Worklogs[n].Date Started}
${Worklogs[n].Time Spent}
${Worklogs[n].TimeSpentFormatted}
${Worklogs[n].BilledHours}
${Worklogs[n].BilledHoursFormatted}
#{end}
or
#{for <VariableName>=WorklogsCount}
Content and Worklog Mappings. Example: ${Worklogs[VariableName].Field}
#{end} |
The image below demonstrates an example of a Word template that iterates over issue worklogs.
or
For a working example of this functionality, check the SampleIterations.docx template in the Template Store.
The image below demonstrates an example of a template in Excel that iterates over issue work logs.
...
or
Issue Sub-Tasks
Because it is not known in advance how many subtasks exist for an issue, you can iterate a section over all the subtasks of an issue. This allows you to create a table that dynamically grows according to the number of existing subtasks. The notation is:
Subtasks Fields | Description |
---|---|
Key | The key of the subtasks |
Summary | The summary of the subtasks |
AssigneeUserDisplayName | The assignee user of the subtasks |
Code Block | ||||
---|---|---|---|---|
| ||||
#{ |
...
Iterating Issue Subtasks
Because it is not known in advance how many subtasks exist for an issue, you can iterate a section over all the subtasks of an issue. This allows you to create a table that dynamically grows according to the number of existing subtasks. The notation is:
...
Code Block | ||||
---|---|---|---|---|
| ||||
#{for subtasks}
${Subtasks[n].Key}
${Subtasks[n].Summary}
${Subtasks[n].AssigneeUserDisplayName}
#{end}
or
#{for <VariableName>=SubtasksCount}
Content and Issue Mappings. Example: ${Subtasks[VariableName].Field}
#{end} |
The image The image below demonstrates an example of a Word template that iterates over issue subtasks.
or
For a working example of this functionality, check the SampleIterations.docx template in the Template Store.
The image The image below demonstrates an example of an Excel template that iterates over issue subtasks.
or
For an example of how to iterate the details of a subtask Parent issue, please check the Iterating the Iterating JQL Queries area below.
...
Issue Components
Because it is not known in advance how many components exist for an issue, you can iterate a section over all the components of an issue. This allows you to create a table that dynamically grows according to the number of existing components. The notation is:
Components Fields | Description |
---|---|
Name | The name of the component |
Description | The description of the component |
Lead | The name of the component lead |
Id | The ID of the component |
ProjectId | The project ID of the component |
AssigneeType | The assignee type of the component |
Code Block | ||||
---|---|---|---|---|
| ||||
#{for components} ${Components[n].Name} ${Components[n].Description} ${fullname:Components[n].Lead} ${Components[n].Id} ${Components[n].ProjectId} ${Components[n].AssigneeType} #{end} |
The image The image below demonstrates an example of a Word template that iterates over issue components.
The image The image below demonstrates an example of an Excel template that iterates over issue components.
...
Issue Status Transitions
Because it is not known in advance how many Status Transitions exist for an issue, you can iterate a section over all the Status Transitions of an issue. This allows you to create a table that dynamically grows according to the number of existing status transitions. The notation is:
Status Transitions Fields | Description |
---|---|
Author | The author of the status transition |
Created | The date the status transition was performed |
OldStatus | The old status of the status transition |
NewStatus | The new status of the status transition |
Code Block | ||||
---|---|---|---|---|
| ||||
#{for statusTransitions}
${StatusTransitions[n].Author}
${dateformat("dd-MM-yyyy HH:mm:ss"):StatusTransitions[n].Created}
${StatusTransitions[n].OldStatus}
${StatusTransitions[n].NewStatus}
#{end}
or
#{for <VariableName>=StatusTransitionsCount}
Content and StatusTransitions Mappings. Example: ${StatusTransitions[VariableName].Field}
#{end} |
The image below demonstrates an example of a Word template that iterates over status transitions.
or
The image below demonstrates an example of an Excel template that iterates over status transitions.
or
Iterating Issue Attached Images
Because it is not known in advance how many Images can exist for an issue (as an attachment), you can iterate a section over all the attached images of an issue to get some metadata about them. This allows you to create a table that dynamically grows according to the number of existing images. The notation is:
...
Code Block | ||||
---|---|---|---|---|
| ||||
#{for statusTransitions}
${StatusTransitions[n].Author}
${dateformat("dd-MM-yyyy HH:mm:ss"):StatusTransitions[n].Created}
${StatusTransitions[n].OldStatus}
${StatusTransitions[n].NewStatus}
#{end}
or
#{for <VariableName>=StatusTransitionsCount}
Content and StatusTransitions Mappings. Example: ${StatusTransitions[VariableName].Field}
#{end} |
The image
Code Block | ||||
---|---|---|---|---|
| ||||
#{for images}
${Images[n].Image|maxwidth=150|maxheight=150}
${Images[n].Name}
${Images[n].ID}
${Images[n].Size}
${Images[n].HumanReadableSize}
${Images[n].Author}
${dateformat("dd-MM-yyyy HH:mm:ss"):Images[n].Created}
${Images[n].MimeType}
${Images[n].ThumbnailURL}
#{end}
or
#{for <VariableName>=ImagesCount}
Content and Images Mappings. Example: ${Images[VariableName].Field}
#{end} |
The image below demonstrates an example of a Word template that iterates over attached images.
or
Info |
---|
Doc. Generartor will automatically read the EXIF orientation property of an image and rotate it to its correct orientation. You can turn this off by adding this property to your template. |
Code Block | ||||
---|---|---|---|---|
| ||||
#{for images}
${Images[n].Image|width=150|height=150}
#{end} |
These values are in pixels and if you only define one of them the image will be rescaled.
Info |
---|
Note that, if you use both maxWidth and width mappings, only the max value will be read. The same behavior happens with height and maxHeight. |
The image below demonstrates an example of an Excel template that iterates over attached images.
or
Iterating Issue Attachments
Because it is not known in advance how many attachments exist in an issue, you can iterate a section over all the attachments of an issue. This allows you to create a table that dynamically grows according to the number of existing attachments. The notation is:
...
Code Block | ||||
---|---|---|---|---|
| ||||
#{for attachments}
${Attachments[n].ID}
${Attachments[n].Name}
${Attachments[n].Author}
${Attachments[n].AuthorFullName}
${dateformat("dd-MM-yyyy HH:mm:ss"):Attachments[n].Created}
${Attachments[n].Size}
${Attachments[n].HumanReadableSize}
${Attachments[n].MimeType}
#{end}
or
#{for <VariableName>=AttachmentsCount}
Content and Issue Mappings. Example: ${Attachments[VariableName].Field}
#{end} |
The image below demonstrates an example of a Word template that iterates over attachments.
or
The image below demonstrates an example of an Excel template that iterates over attachments.
or
Iterating Issue Labels
Because it is not known in advance how many labels exist in an issue, you can iterate a section over all the labels of an issue. The notation is:
...
Code Block |
---|
#{for labels}
${Labels[n].Name}
#{end}
or
#{for <VariableName>=LabelsCount}
${Labels[VariableName].Name}
#{end} |
The image below demonstrates an example of a Word template that iterates over labels.
or
The image below demonstrates an example of an Excel template that iterates over labels.
or
Iterating Project Versions from an Issue
You can iterate over all project versions to which the issue belong to. The notation is:
...
Start date
...
Release date
...
Code Block |
---|
#{for projectVersions}
${ProjectVersions[n].Name}
${ProjectVersions[n].Description}
${dateformat("dd-MM-yyyy"):ProjectVersions[n].Start date}
${dateformat("dd-MM-yyyy"):ProjectVersions[n].Release date}
#{end}
or
#{for <VariableName>=ProjectVersionsCount}
${ProjectVersions[VariableName].Name}
${ProjectVersions[VariableName].Description}
${dateformat("dd-MM-yyyy"):ProjectVersions[VariableName].Start date}
${dateformat("dd-MM-yyyy"):ProjectVersions[VariableName].Release date}
#{end} |
The image below demonstrates an example of a Word template that iterates over project version.
or
The image below demonstrates an example of an Excel template that iterates over project version.
or
Iterating JQL Queries
You can iterate issues that are the result of a JQL Query. The syntax is similar to the other iterations, but there is a clause parameter that will receive the JQL Query. A few examples are provided below.
Code Block | ||||
---|---|---|---|---|
| ||||
a simple example iterating the details of issues from a specified Project:
#{for i=JQLIssuesCount|clause=project = DEMO}
${JQLIssues[i].Key}
${JQLIssues[i].Summary}
#{end}
or a more advanced example iterating the details of issues linked with the current Issue:
#{for m=JQLIssuesCount|clause=issuekey in linkedIssues (${Links[j].Key})}
Linked Issue ${JQLIssues[m].Summary} has ${JQLIssues[m].LinksCount} links
#{end}
or an also advanced example iterating the details of the Parent issue from the current Subtask:
#{for i=JQLIssuesCount|clause=issuekey = ${ParentIssueKey}}
${JQLIssues[i].Key}
${JQLIssues[i].Id}
${JQLIssues[i].Description}
#{end}
|
The image below demonstrates an example of a Word template that iterates over issue subtasksstatus transitions.
For a working example of this functionality, check the template Sample Iterations in the Template Store.
...
or
The image below demonstrates an example of an Excel
...
template that iterates over status transitions.
or
Issue Attached Images
...
Info |
---|
You can also use a Filter Name or a Filter Id as a clause. For more info, read this. |
...
Because it is not known in advance how many commits Images can exist for an issue (as an attachment), you can iterate a section over all the commits attached images of an issue to get some metadata about them. This allows you to create a table that dynamically grows according to the number of existing commitsimages. The notation is:
Commits Attachments Images Fields | Description | ||
---|---|---|---|
URL | The URL of the link | ||
CreatedDateTime | The date the commit was created | ||
ID | The ID of the attached image | ||
Image | The image of the attached image | ||
Name | The name of the attached image | ||
Size | The size of the attached image | ||
HumanReadableSize | The size of the attached image | Message | The message of the commit |
Author | The author of the commit |
...
attached image | |
Created | The date the attached image was created |
MimeType | The type of the attached image |
ThumbnailURL | The URL to the thumbnail of the image |
Code Block | ||||
---|---|---|---|---|
| ||||
#{for commitsimages} ${CommitsImages[n].Author} ${CommitsImage|maxwidth=150|maxheight=150} ${Images[n].URLName} ${CommitsImages[n].MessageID} ${CommitsImages[n].CreatedDateTimeSize} Here we have the FilesCount where we can get all the files associated with a commit. #{for m=Commits ${Images[n].FilesCountHumanReadableSize} ${CommitImages[n].FilesCount[m].Path} ${CommitAuthor} ${dateformat("dd-MM-yyyy HH:mm:ss"):Images[n].Created} ${Images[n].FilesCount[m].URLMimeType} ${CommitImages[n].FilesCount[m].ChangeTypeThumbnailURL} # #{end} #{end} or #{for <VariableName>=CommitsCountImagesCount} Content and IssueImages Mappings. Example: ${CommitsImages[VariableName].Field} #{end} |
Iterating Issue Branches
Because it is not known in advance how many branches exist for an issue, you can iterate a section over all the branches of an issue. This allows you to create a table that dynamically grows according to the number of existing branches. The notation is:
Branches Fields | Description |
---|---|
URL | The URL of the Branch |
Name | The name of the Branch |
RepositoryName | The name of the repository |
RepositoryURL | The URL of the repository |
The image below demonstrates an example of a Word template that iterates over attached images.
or
Info |
---|
Doc. Generator will automatically read the EXIF orientation property of an image and rotate it to its correct orientation. You can turn this off by adding this property to your template. |
Code Block | ||||
---|---|---|---|---|
| ||||
#{for branches} ${Branches[n].URL} ${Branches[n].Name} ${Branches[n].RepositoryName{for images} ${BranchesImages[n].RepositoryURLImage|width=150|height=150} #{end} or #{for <VariableName>=BranchesCount} Content and Issue Mappings. Example: ${Branches[VariableName].Field} #{end} |
Iterating Issue Pull Requests
#{end} |
These values are in pixels and if you only define one of them the image will be rescaled.
Info |
---|
Note that, if you use both maxWidth and width mappings, only the max value will be read. The same behavior happens with height and maxHeight. |
The image below demonstrates an example of an Excel template that iterates over attached images.
or
Issue Attachments
Because As it is not known in advance how many pull requests attachments exist for in an issue, you can iterate a section over all the pull requests of attachments of an issue. This allows you to create a table that dynamically grows according to the number of existing pull requestsattachments. The notation is:
...
The URL of the Branch
...
RepositoryName
...
RepositoryURL
...
The URL of the repository
...
is:
Attachments Fields | Description |
---|---|
ID | The ID of the attachment |
Name | The name of the attachment |
Author | The author of the attachment |
AuthorFullName | The full name of the author of the attachment |
Created | The date the attachment was created |
Size | The size of the attachment |
HumanReadableSize | The formatted size of the attachment |
MimeType | The type of the attachment |
You can get information about reviewers from each pull request:
...
Code Block | ||||
---|---|---|---|---|
| ||||
#{for pullRequests} ${PullRequests[n].URL} ${PullRequests[n].Name} ${PullRequests[n].RepositoryName attachments} ${PullRequestsAttachments[n].RepositoryURLID} ${PullRequests[n].CommentsCount} (This represents the number of comments in a pull request) ${PullRequestsAttachments[n].Status} ${PullRequests[n].LastUpdated} Here we have the PullRequestReviews where we can get all the reviewers for this pull request. #{for m=PullRequestsName} ${Attachments[n].PullRequestReviewersAuthor} ${PullRequestsAttachments[n].PullRequestReviewers[m].NameAuthorFullName} ${dateformat("dd-MM-yyyy HH:mm:ss"):Attachments[n].Created} ${PullRequestsAttachments[n].PullRequestReviewers[mSize} ${Attachments[n].ApprovedHumanReadableSize} #{end ${Attachments[n].MimeType} #{end} or #{for <VariableName>=PullRequestsCountAttachmentsCount} Content and Issue Mappings. Example: ${PullRequestsAttachments[VariableName].Field} #{end} |
Iterating Issue Builds
The image below demonstrates an example of a Word template that iterates over attachments.
or
The image below demonstrates an example of an Excel template that iterates over attachments.
or
Issue Labels
Because Because it is not known in advance how many builds labels exist for in an issue, you can iterate a section over all the builds the labels of an issue. This allows you to create a table that dynamically grows according to the number of existing builds. The notation is:
Builds Attachments Fields | Description |
---|---|
ProjectNameName | The build project name of the label |
ProjectKey | The build project key |
...
Plans.Key
...
Plans.BuildNumber
...
Code Block |
---|
#{for labels}
${Labels[n].Name}
#{end}
or
#{for <VariableName>=LabelsCount}
${Labels[VariableName].Name}
#{end} |
The image below demonstrates an example of a Word template that iterates over labels.
or
The image below demonstrates an example of an Excel template that iterates over labels.
or
Project Versions
You can iterate over all project versions to which the issue belong to. The notation is:
Attachments Fields | Description |
---|---|
Name | The name of the project version |
Description | The description of the project version |
Start date | The Start Date of the project version |
Release date | The Release Date of the project version |
Code Block |
---|
#{for projectVersions}
${ProjectVersions[n].Name}
${ProjectVersions[n].Description}
${dateformat("dd-MM-yyyy"):ProjectVersions[n].Start date}
${dateformat("dd-MM-yyyy"):ProjectVersions[n].Release date |
Code Block | ||||
---|---|---|---|---|
| ||||
#{for builds} ${Builds[n].ProjectName} ${Builds[n].ProjectKey} Here we have the each Build Plans where we can get all the individual plans for this project and the correspondent build in existence for this plan. #{for m=Builds[n].Plans} ${Builds[n].Plans[m].Key} ${Builds[n].Plans[m].Name} ${Builds[n].Plans[m].BuildNumber} ${Builds[n].Plans[m].BuildKey} ${Builds[n].Plans[m].BuildDuration} ${Builds[n].Plans[m].BuildFinishedDate} #{end} #{end} or #{for <VariableName>=BuildsCountProjectVersionsCount} Content and Issue Mappings. Example: ${Builds[VariableName].Field${ProjectVersions[VariableName].Name} ${ProjectVersions[VariableName].Description} ${dateformat("dd-MM-yyyy"):ProjectVersions[VariableName].Start date} ${dateformat("dd-MM-yyyy"):ProjectVersions[VariableName].Release date} #{end} |
Iterating Issue Reviews
Because it is not known in advance how many reviews exists for an issue, you can iterate a section over all the pull requests of an issue. This allows you to create a table that dynamically grows according to the number of existing reviews. The notation is:
...
The review ID, e.g., 1
...
The URL of the review
...
The review status
...
} |
The image below demonstrates an example of a Word template that iterates over project version.
or
The image below demonstrates an example of an Excel template that iterates over project version.
or
Iterating JQL Queries
You can iterate issues that are the result of a JQL Query. The syntax is similar to the other iterations, but there is a clause parameter that will receive the JQL Query. A few examples are provided below.
...
Code Block | ||||
---|---|---|---|---|
| ||||
a simple example iterating the details of issues from a specified Project: #{for reviews} ${Reviews[n].Idi=JQLIssuesCount|clause=project = DEMO} ${ReviewsJQLIssues[ni].URLKey} ${ReviewsJQLIssues[ni].Status} ${Reviews[n].Title} ${Reviews[n].Author} ${Reviews[n].Moderator} Here we have the Reviewers for each review where we can get all the individual reviewers for this review. #{for m=Reviews[n].Reviewers} ${Reviews[n].Reviewers[m].Username} ${Reviews[n].Reviewers[m].Completed} #{end} #{end} or #{for <VariableName>=ReviewsCount} Content and Issue Mappings. Example: ${Reviews[VariableName].Field} #{end}Summary} #{end} or a more advanced example iterating the details of issues linked with the current Issue: #{for m=JQLIssuesCount|clause=issuekey in linkedIssues (${Links[j].Key})} Linked Issue ${JQLIssues[m].Summary} has ${JQLIssues[m].LinksCount} links #{end} or an also advanced example iterating the details of the Parent issue from the current Subtask: #{for i=JQLIssuesCount|clause=issuekey = ${ParentIssueKey}} ${JQLIssues[i].Key} ${JQLIssues[i].Id} ${JQLIssues[i].Description} #{end} |
The image below demonstrates an example of a Word template that iterates over issue subtasks.
The image below demonstrates an example of an Excel template that iterates over issue subtasks.
Info |
---|
You can also use a Filter Name or a Filter Id as a clause. For more info, read this. |
Applying filters to Iterations
If you want to take the previous iterations over comments, subtasks and issue links to another level of control, you can use a JavaScript filter to define over which issues the iteration will be made. This can be useful in the following scenarios:
- Iterating over linked issues that are only of a specific issue type
- Iterating over subtasks of a specific issue type
- Iterating over linked issues with a specific priority
- Iterating over comments created by a specific user
The notation for applying filters to the iterations is:
Code Block | ||||
---|---|---|---|---|
| ||||
#{for <VariableName>=<LinksCount|SubtasksCount|CommentsCount|WorklogsCount>|filter=%{<Javascript>}} Content here #{end} |
- VariableName is the name of the variable to use as the iteration index.
LinksCount|SubtasksCount|CommentsCount indicates over which type of entities you want to iterate.
- Filter indicates the filter to be applied in the iteration.
Notice that as the filter is evaluated as a JavaScript expression, which provides flexibility in the definition of the conditions. You can use and (&&), or (||) and other logical operators supported by the JavaScript language.
It is also possible to format fields inside iteration filters. For more information on formatters, see Native Iterations.
The image below demonstrates an example of a template that iterates over issue links and comments with filters being applied.
Links Bugs with High Priority:
Nested Iterations:
For a working example of this functionality, check the template Sample Iterations in the Template Store.
Iterating in the same line of the document
You can also possible to iterate values in the same line of the document. This can be useful if you want to display a list of Subtasks on Linked Issues in the same line, separated by commas or spaces.
Code Block | ||||
---|---|---|---|---|
| ||||
Users that added comments to this issue: #{for comments}${Comments[n].Author} #{end} Subtasks of this issue: #{for j=SubtasksCount}${Subtasks[j].Key};#{end} Linked issues this issue duplicates: #{for j=LinksCount|filter=%{'${Links[j].LinkType}'.equals('duplicates')}}${Links[j].Key} #{end} |
Iterating in the same cell in an Excel document
You can also iterate values in the same cell in an Excel document. You can achieve this by simply making your Iteration inside the same cell.
You can use all the Iterations that you are used to and construct them in the exact same way, the difference being that you only use one cell to do them.
Code Block | ||||
---|---|---|---|---|
| ||||
Issue iteration as a demonstration. Copy this iteration below and paste it into a cell. &{for issues} ${Key} &{end} |
Iterating with the BREAK or CONTINUE statement
You can iterate anything, set up a Conditional expression and then utilize the BREAK and CONTINUE statements.
The way to do this is by doing a normal Conditional expression and using the mapping #{break} or #{continue} inside it.
Code Block | ||||
---|---|---|---|---|
| ||||
Imagine that you have a Jira Issue that contains these comments: - Hello - World - Greetings - Hi For the Break functionality, lets say that you want to stop the iteration if the current comment is "World". Here is the template for that: #{for comments} Current Comment: ${Comments[n].Body} #{if (%{'${Comments[n].Body}'.equals('World')})} #{break} #{end} Current Comment Author: ${Comments[n].Author} #{end} In this case, it will print the comment "Hello" and it´s author. Next it will print the comment Body "World" but since the Conditional expression is true, it will stop the iteration all together and not print anything else. Note: Anything after the #{break} mapping will not be printed in the exported document. For the Continue functionality, lets say that you want to skip to the next iteration if the current comment is "World", bypassing the Author mapping for this iteration. Here is the template for that: #{for comments} Current Comment: ${Comments[n].Body} #{if (%{'${Comments[n].Body}'.equals('World')})} #{continue} #{end} Current Comment Author: ${Comments[n].Author} #{end} In this case, it will print the comment "Hello" and it´s author. Next, it will print the comment Body "World" but since the Conditional expression is true, it will continue to the next iteration, not printing the Author of the "World" comment. |
Iterating Parent Issues
You can iterate a section over all the parent issues of an issue. This allows you to create a table that dynamically grows according to the information you want to see from parent issues.
Imagine that you have a Jira Issue that contains a Key, Summary, Description and further information. From now on, you are able to get all the information from a parent issue. In order to get those fields, you just need to have the following definition:
${Parent.<Field>} |
Example:
Code Block | ||||
---|---|---|---|---|
| ||||
&{for issues|filter=%{'${IssueTypeName}'.equals('Sub-task')}} ${Parent.Key} ${Parent.Summary} ${Parent.Description} ${wiki:Parent.Description} ${html:Parent.Description} ${dateformat(“dd-MM-yyyy HH:mm:ss”):Parent.date} ${emailaddress:Parent.userpicker} &{end} This example only has a few fields, but this new feature allows you to get all information from a parent issue. |
Sorting iterations
Imagine that you have an iteration and want to sort it by any field that it can export normally. This will be the header for such an iteration:
#{for comments|sortby=<Iteration mapping>} |
NOTE: The mapping after the "sortby" must be equal to the supported mappings for each Iteration.
Example:
Code Block | ||||
---|---|---|---|---|
| ||||
This iteration will be sorted by the Body of all the comments in the issue. #{for comments|sortby=Body} ${Comments[n].Author} ${Comments[n].Body} #{end} |
Sort By on multi issue export
The sortby can also be used to sort a &{for issues} iteration on a Bulk Export.
Code Block | ||||
---|---|---|---|---|
| ||||
&{for issues|sortby=IssueTypeName} ${Key} - ${IssueTypeName} &{end} |
Info | ||
---|---|---|
| ||
asc and desc can be defined in order to define how do you want to sort your data. The default value is asc. |