Why doesn't the diff function work correctly with date values in lists?

Mike.Mikaelian

I've run into an issue in Jira Automation that looks suspiciously like a bug. I wanted to take the results of a JQL search and total up the number of days between two date values in the results. I first used the Branch Rule widget to search up each issue individually and arrived at a function that properly calculated the number I was looking for. However, the Branching Rule widget cannot pass values back to the main rule, so I was unable to do much of anything useful with this result.

To remedy this, I used the Lookup Issues widget to get the same search results and then used a modified version of the same function (I had to slightly change the smartvalues to remove the "issue." prefix, but otherwise it's the same function, see below). When I did, it seemed incapable of properly calculating the same values. Here's the bug report:

Steps to Reproduce

1. Create an automation rule you can trigger manually
2. Add a Lookup Issues action that performs a search for issues that have to date fields used to define a range of time (we'll call them startDate and endDate).
3. Add a Log action that calculates the difference between the two dates for each issue in the search result:
   {{#lookupIssues}} {{startDate.format("M/d")}}-{{endDate.format("M/d")}} {{startDate.jiraDateTime.toDate.diff(endDate.jiraDateTime.toDate.plusDays(1))}} {{/}}
4. Run the rule
5. Look at the Audit Log

Expected Results

The calculated numbers should equal the number of days between (and including) the startDate and endDate for each issue.
Ex: 10/11-10/11 1 day, 10/17-10/23 7 days, 10/7-10/7 1 day, 10/18-10/18 1 day, 10/8-10/8 1 day

Actual Results

After the first result, there is no rhyme or reason to the results except that they alternate between positive and negative values.
Ex: 10/11-10/11 1 day 10/17-10/23 -5 days 10/7-10/7 5 days 10/18-10/18 -6 days 10/8-10/8 4 days

Eduardo_u22ick

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:

1. 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.

2. 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 <em><strong>Branch Rule</strong></em> 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:

 

{{<span>#lookupIssues}}</span>
<span>Start:</span> {{<span>startDate.format("M/d")</span>}}, <span>End:</span> {{<span>endDate.format("M/d")</span>}} 
<span>Difference:</span> {{<span>startDate.jiraDate.diff(endDate.jiraDate)</span>}}
{{<span>/</span>}}

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 <em><strong>.jiraDate</strong></em> 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:

 

 {{<span>startDate.jiraDate.format("yyyy-MM-dd")</span>}} <span>-</span> {{<span>endDate.jiraDate.format("yyyy-MM-dd")</span>}} 
<span>Days:</span> {{<span>startDate.jiraDate.diff(endDate.jiraDate)</span>}}

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:

 

{{<span>#lookupIssues}}</span>
<span>Start Date Raw:</span> {{<span>startDate</span>}}, <span>End Date Raw:</span> {{<span>endDate</span>}} 
{{<span>startDate.jiraDate.diff(endDate.jiraDate)</span>}}
{{<span>/</span>}}

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 <em><strong>plusDays(1)</strong></em> 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.