The issue you're encountering with Jira Automation's diff function on date values in a list is likely related to how the lookupIssues smart value is processed within a list. Specifically, there could be an inconsistency in how Jira handles date arithmetic within loops or iterations involving lookupIssues.
Here’s a breakdown of why this might be happening and possible ways to address it:
Why the issue occurs:
Jira DateTime Conversion in Lists: When using lookupIssues, Jira may not correctly parse or handle date values when used in list processing (loops). This can result in inconsistent behavior when performing date calculations such as diff.
The inconsistent output you see (alternating positive and negative values) suggests that the way Jira Automation processes these dates inside a list context might not be robust. This could be due to:
- Issues with time zone conversions.
- Incorrect handling of date objects when iterating over multiple issues in the
lookupIssues block. - Inconsistent recognition of the "plusDays(1)" operation within list contexts.
Smart Values and Context Changes: In the Branch Rule approach, the context of the issue is local and confined to the issue being processed at that moment. This allows date manipulations to work correctly. However, in the lookupIssues approach, the context shifts to an entire list, and the diff operation might not correctly handle date values because the logic is being applied at a different context level (list versus individual issue).
Possible Fixes:
1. Calculate the Difference in the Individual Issue Context:
If possible, use Branch Rule again but try to summarize or pass data through alternative means (e.g., storing values in variables or passing data using JSON). This way, you ensure that the diff function runs in the proper context where it works reliably.
2. Workaround for lookupIssues:
Modify the way the dates are handled in the lookupIssues block by isolating each date calculation outside the list processing. You can try something like this:
{{#lookupIssues}}
Start: {{startDate.format("M/d")}}, End: {{endDate.format("M/d")}}
Difference: {{startDate.jiraDate.diff(endDate.jiraDate)}}
{{/}}
This removes the .toDate and .plusDays(1) from the calculation. You may also want to ensure both startDate and endDate are correctly formatted as dates before performing the diff operation. Use .jiraDate instead of .jiraDateTime.toDate as this could help simplify things.
3. Ensure Consistent Date Formats:
Ensure both dates (startDate and endDate) are consistently formatted in the same time zone and date format. You can try explicitly setting both date fields to use the same date format before applying the diff calculation, like this:
{{startDate.jiraDate.format("yyyy-MM-dd")}} - {{endDate.jiraDate.format("yyyy-MM-dd")}}
Days: {{startDate.jiraDate.diff(endDate.jiraDate)}}
4. Debugging with Log Action:
To further investigate, you could log the raw values for startDate and endDate just before the diff function to verify that the dates are correct and in the expected format:
{{#lookupIssues}}
Start Date Raw: {{startDate}}, End Date Raw: {{endDate}}
{{startDate.jiraDate.diff(endDate.jiraDate)}}
{{/}}
This can help identify if there are any anomalies in the raw date values being processed.
It seems like the diff function isn't handling the list processing context as expected. Modifying the logic to calculate the difference outside the list, simplifying the date conversion (avoiding .toDate and plusDays(1) within the loop), and ensuring both dates are in the same format could help. If the issue persists, it might indeed be a bug, and you could raise it with Atlassian support for further investigation.
You must be a registered user to add a comment. If you've already registered, sign in. Otherwise, register and sign in.