Page tree

You are on the Xporter Server documentation. If you are looking for Xporter Cloud documentation, you can find it in this page.

Skip to end of metadata
Go to start of metadata

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 done. The notation is:

FieldDescription
HistoryEntriesCountReturns the number of changes made.
AuthorReturns the user who made the change.
CreatedDate of the change
ChangedItemsCoutReturns the number of fields changed in the current change.
ChangedItem
FieldDescription
FieldReturns the name of the field in which the value was changed.
FromReturns the old value.
ToReturns the new value.
Expand to see the sample code
#{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 <VariableName>=HistoryEntriesCount}
   Content and Issue History Mappings. Example:${fullname:HistoryEntries[VariableName].Field} 
#{end}

The documents below demonstrate examples both in Word and Excel templates that iterates over the issue's changelogs.
word.pngIterating_Issue_History.docx
Iterating_Issue_History.xlsx


Iterating Issue Activity

Changes to issues are registered in the Issue Activity, but it is not known in advance how many changes are going to be made. You can iterate a section over all the activities of an issue. This allows you to create a table that dynamically grows according to the number of existing activities. The notation is:

FieldDescription
Title

The title of the issue

SummaryThe summary of the activity
ContentWhen an activity involves a change in the Issue contents, this field displays the new contents
AuthorThe author of the activity
AuthorEmailThe email of the author of the activity
PublishedThe time the issue was published
UpdatedThe time the issue was updated
CategoriesWhen an activity regards an Issue Status change, this field displays the new Issue Status
Expand to see the sample code
#{for activityEntries}
   ${ActivityEntries[n].Title}
   ${ActivityEntries[n].Summary}
   ${ActivityEntries[n].Content}
   ${ActivityEntries[n].Author}
   ${ActivityEntries[n].AuthorEmail}
   ${dateformat("dd-MM-yyyy HH:mm:ss"):ActivityEntries[n].Published}
   ${dateformat("dd-MM-yyyy HH:mm:ss"):ActivityEntries[n].Updated}
   ${ActivityEntries[n].Categories}
#{end}
 
or
 
#{for <VariableName>=ActivityEntriesCount}
   Content and Issue Mappings. Example: ${ActivityEntries[VariableName].Field}
#{end}

We suggest that you use the html function to render the data because almost all content is HTML, e.g., ${html:ActivityEntries[n].Title}

The documents below demonstrate examples both in Word and Excel templates that iterate over the activity from the issues.
word.pngIterating_Issue_Activity.docx
Iterating_Issue_Activity.xlsx


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:

FieldDescription
AppType

The application type of the link

Application ValueDescription

JIRA

Link from the same Jira Instance
External JiraLink from the another Jira Instance
ConfluenceLink from a Confluence page
ExternalExternal link
LinkTypeThe type of the link
KeyThe key of the linked issue
SummaryThe summary of the linked issue
URL

The URL of the link

Expand to see the sample code
#{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}


Note:  When the link you are iterating is of AppTypes External Jira or Confluence, the name is obtained using the Summary property.
The documents below demonstrate examples both in Word and Excel templates that iterate over linked issues.
word.pngIterating_Issue_Links.docx
Iterating_Issue_Links.xlsx


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:

FieldDescription
Author

The author of the comment

AuthorFullNameThe full name of the author of the comment
BodyThe comment
CreatedThe date the comment was posted
GroupLevelThe group level of the comment
Expand to see the sample code
#{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 documents below demonstrate examples both in Word and Excel templates that iterates over the issue comments.
word.pngIterating_Issue_Comments.docx
Iterating_Issue_Comments.xlsx


Iterating Issue Worklogs

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 allows you to create a table that dynamically grows according to the number of existing worklogs. The notation is:

Field

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)

Expand to see the sample code
#{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 documents below demonstrate examples both in Word and Excel templates that iterates over the issue worklogs.
word.pngIterating_Issue_Worklogs.docx
Iterating_Issue_Worklogs.xlsx


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:

FieldDescription
KeyThe key of the subtasks
SummaryThe summary of the subtasks
AssigneeUserDisplayNameThe assignee user of the subtasks
Expand to see the sample code
#{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}

For an example of how to iterate the details of a subtask Parent issue, please check the Iterating JQL Queries.
The documents below demonstrate examples both in Word and Excel templates that iterates over the issue subtasks.
word.pngIterating_Issue_Subtasks.docx
Iterating_Issue_Subtasks.xlsx


Iterating 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:

FieldDescription
NameThe name of the component
DescriptionThe description of the component
LeadThe name of the component lead
IdThe ID of the component
ProjectIdThe project ID of the component
AssigneeTypeThe assignee type of the component
Expand to see the sample code
#{for components}
   ${Components[n].Name}
   ${Components[n].Description}
   ${fullname:Components[n].Lead}
   ${Components[n].Id}
   ${Components[n].ProjectId}
   ${Components[n].AssigneeType}
#{end}

OR

#{for <VariableName>=ComponentsCount}
   Content and Issue Mappings. Example: ${Components[VariableName].Field}
#{end}

The documents below demonstrate examples both in Word and Excel templates that iterates over the issue components.
word.pngIterating_Issue_Components.docx
Iterating_Issue_Components.xlsx


Iterating 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:

FieldDescription
AuthorThe author of the status transition
CreatedThe date the status transition was performed
OldStatusThe old status of the status transition
NewStatusThe new status of the status transition
Expand to see the sample code
#{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 documents below demonstrate examples both in Word and Excel templates that iterates over the issue status transitions.
word.pngIterating_Issue_StatusTransitions.docx
Iterating_Issue_StatusTransitions.xlsx


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:

FieldDescription
IDThe ID of the attached image
ImageThe image of the attached image
NameThe name of the attached image
SizeThe size of the attached image
HumanReadableSizeThe size of the attached image
AuthorThe author of the attached image
CreatedThe date the attached image was created
MimeTypeThe type of the attached image
ThumbnailURLThe URL to the thumbnail of the image
Expand to see the sample code
#{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 documents below demonstrate examples both in Word and Excel templates that iterate over the attached images for each issue.
word.pngIterating_Issue_AttachedImages.docx
Iterating_Issue_AttachedImages.xlsx

  • Xporter 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.

Since Xporter 5.5.0, you can use the width and height of the mapping to define the exact width and height of the printed image.

Expand to see the sample code
#{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.

  • 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.
  • You can iterate over ${Images[n].Image} in Excel on Xporter version 5.4.0 and above.

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:

FieldDescription
IDThe ID of the attachment
NameThe name of the attachment
AuthorThe author of the attachment
AuthorFullNameThe full name of the author of the attachment
CreatedThe date the attachment was created
SizeThe size of the attachment
HumanReadableSizeThe formatted size of the attachment
MimeTypeThe type of the attachment
Expand to see the sample code
#{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 documents below demonstrate examples both in Word and Excel templates that iterates over the issue's attachments.
word.pngIterating_Issue_Attachments.docx
Iterating_Issue_Attachments.xlsx


Iterating Issue Labels

FieldDescription
NameThe name of the label
Expand to see the sample code
#{for labels}
   ${Labels[n].Name}
#{end}
 
or
 
#{for <VariableName>=LabelsCount}
  ${Labels[VariableName].Name}
#{end}

The documents below demonstrate examples both in Word and Excel templates that iterates over the issue's labels.
word.pngIterating_Issue_Labels.docx
Iterating_Issue_Labels.xlsx


Iterating Project Versions from an Issue

You can iterate over all project versions to which the issue belongs. The notation is:

FieldDescription
NameThe name of the project version
DescriptionThe description of the project version
Start date
The Start Date of the project version
Release date
The Release Date of the project version
Expand to see the sample code
#{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 documents below demonstrate examples both in Word and Excel templates that iterates over the issue's project versions.
word.pngIterating_Issue_ProjectVersions.docx
Iterating_Issue_ProjectVersions.xlsx


Iterating Issue Commits

Because it is not known in advance how many commits exist for an issue, you can iterate a section over all the commits of an issue. This allows you to create a table that dynamically grows according to the number of existing commits. The notation is:

FieldDescription
URL

The URL of the link

CreatedDateTimeThe date the commit was created
Message
The message of the commit
Author
The author of the commit


In order to extract more information from Commits, it is possible to get information from the files that were committed:  

Commits files count FieldsDescription
FilesCount.PathThe path of the file was committed
FilesCount.URLThe URL of the file was committed
FilesCount.ChangeTypeIdentify the type of change that occurred in the commit
Expand to see the sample code
#{for commits}
	${Commits[n].Author} 
	${Commits[n].URL} 
	${Commits[n].Message}
	${Commits[n].CreatedDateTime}
	
	Here we have the FilesCount where we can get all the files associated with a commit.
	#{for m=Commits[n].FilesCount}
		${Commit[n].FilesCount[m].Path}
		${Commit[n].FilesCount[m].URL}
		${Commit[n].FilesCount[m].ChangeType}
	#{end}
#{end}
 
or
 
#{for <VariableName>=CommitsCount}
   Content and Issue Mappings. Example: ${Commits[VariableName].Field}
#{end}

 The documents below demonstrate examples both in Word and Excel templates that iterates over the issue's commits.
word.pngIterating_Issue_Commits.docx
Iterating_Issue_Commits.xlsx


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:

Field

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
Expand to see the sample code
#{for branches}
  ${Branches[n].URL}
  ${Branches[n].Name}
  ${Branches[n].RepositoryName}
  ${Branches[n].RepositoryURL}
#{end}
 
or
 
#{for <VariableName>=BranchesCount}
   Content and Issue Mappings. Example: ${Branches[VariableName].Field}
#{end}

  The documents below demonstrate examples both in Word and Excel templates that iterates over the issue's branches.
word.pngIterating_Issue_Branches.docx
Iterating_Issue_Branches.xlsx


Iterating Issue Pull Requests

As it is not known in advance how many pull requests exist 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 pull requests. The notation is:

FieldDescription

URL

The URL of the Branch

Name

The name of the Branch

RepositoryName

The name of the repository

RepositoryURL

The URL of the repository

CommentsCount

Counts the number of comments in the pull request

Status

The status of the pull request

LastUpdated

The last time the pull request was updated

PullRequestReviewers.Name

The name of the pull request reviewer

PullRequestReviewers.Approved

Indicates the approval of the pull request reviewer


You can get information about reviewers from each  pull request:

Pull Request reviewers FieldsDescription
PullRequestReviewers.NameThe name of the pull request reviewer
PullRequestReviewers.ApprovedIndicates the approval of the pull request reviewer
Expand to see the sample code
#{for pullRequests}
  	${PullRequests[n].URL}
  	${PullRequests[n].Name}
  	${PullRequests[n].RepositoryName}
  	${PullRequests[n].RepositoryURL}
	${PullRequests[n].CommentsCount} (This represents the number of comments in a pull request)
	${PullRequests[n].Status}
	${PullRequests[n].LastUpdated}
 
	Here we have the PullRequestReviews where we can get all the reviewers for this pull request.
	#{for m=PullRequests[n].PullRequestReviewers}
  		${PullRequests[n].PullRequestReviewers[m].Name}
  		${PullRequests[n].PullRequestReviewers[m].Approved}
	#{end}
#{end}
 
or
 
#{for <VariableName>=PullRequestsCount}
   Content and Issue Mappings. Example: ${PullRequests[VariableName].Field}
#{end}

 The documents below demonstrate examples both in Word and Excel templates that iterates over the issue's pull requests.
word.pngIterating_Issue_PullRequests.docx
Iterating_Issue_PullRequests.xlsx


Iterating Issue Builds

 Because it is not known in advance how many builds exist for an issue, you can iterate a section over all the builds of an issue. This allows you to create a table that dynamically grows according to the number of existing builds. The notation is:

FieldDescription
ProjectNameThe build project name
ProjectKeyThe build project key


In order to get more information, you can get all the individual plans for the project and the corresponding build.

Build plans Fields

Description

Plans.Key

The plans build key

Plans.Name

Theplansbuild name

Plans.BuildNumber

The plans build number

Plans.BuildKey

The plans build key

Plans.BuildDuration

The duration of the build

Plans.BuildFinishedDate

The date when plans build was finished

Expand to see the sample code
#{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>=BuildsCount}
   Content and Issue Mappings. Example: ${Builds[VariableName].Field}
#{end}

  The documents below demonstrate examples both in Word and Excel templates that iterates over the issue's builds.
word.pngIterating_Issue_Builds.docx
Iterating_Issue_Builds.xlsx


Iterating Issue Reviews

Because it is not known in advance how many reviews exist 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: 

FieldDescription
Id

The review ID, e.g., 1

URL

The URL of the review

Status

The review status

TitleThe title of the review
AuthorThe author of the review
ModeratorThe moderator of the review


In order to get all the reviewers from this review, you can use the following mappings:


Reviewers FieldsDescription
Reviewers.UsernameThe username of each reviewer
Reviewers.CompletedThe completed name of each reviewer
Expand to see the sample code
#{for reviews}
  	${Reviews[n].Id}
  	${Reviews[n].URL}
  	${Reviews[n].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}

The documents below demonstrate examples both in Word and Excel templates that iterates over the issue's reviews.
word.pngIterating_Issue_Reviews.docx
Iterating_Issue_Reviews.xlsx


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:

Expand to see the sample code
&{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.

The documents below demonstrate examples both in Word and Excel templates that iterates over the parent issues.
word.pngIterating_Issue_Parents.docx
Iterating_Issue_Parents.xlsx


Iterating Issues In Epic

All fields listed here are available on IssuesInEpic[n] because they represent an issue.

Because it is not known in advance how many issues exist for an epic, you can iterate a section over all the issues of an epic issue. This allows you to create a table that dynamically grows according to the number of existing issues. The notation is:

Expand to see the sample code
#{for IssuesInEpic}
   ${IssuesInEpic[n].Key}
   ${IssuesInEpic[n].Summary}
   ${IssuesInEpic[n].Description}
   ${IssuesInEpic[n].Epic Link.Key}
#{end}
  
or
  
#{for <VariableName>=IssuesInEpicCount}
   Content and Issue Mappings. Example: ${IssuesInEpic[VariableName].Field}
#{end}

The documents below demonstrate examples both in Word and Excel templates that iterates over the issues in epic.
word.pngIterating_IssuesInEpic.docx
Iterating_IssuesInEpic.xlsx


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.

Expand to see the sample code
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 documents below demonstrate examples both in Word and Excel templates with JQL examples.
word.pngIterating_JQLQueries.docx
Iterating_JQLQueries.xlsx

You can also use a Filter Name or a Filter Id as a clause. For more info, check [http://confluence.xpand-addons.com/display/public/XPORTER/JQL]


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:

Expand to see the sample code
#{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 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 Iterations.

The document below demonstrates an example of a template that iterates over issue links and comments with filters being applied.

Links_with_Filter.docx


Iterating in the same line of the document

You can also possible 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. 


Expand to see the sample code
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.

Expand to see the sample code
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. 

Expand to see the sample code
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, Xporter for Jira 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, Xporter for Jira 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.

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:

Expand to see the sample code
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 Bulk export

The sortby can also be used to sort a &{for issues} iteration on a Bulk Export.

Expand to see the sample code
&{for issues|sortby=IssueTypeName}
${Key} - ${IssueTypeName}
&{end}

Sorting Criteria

asc and desc can be defined in order to define how do you want to sort your data. The default value is asc.

  • No labels