This article was originally published on the Atlassian Community.
Frictionless issue tracking and resolution form the basis of project management tools like Jira. But when teams use different Jira instances like Jira Cloud and Jira on-premise, managing information between them can be challenging.
So how would you sync issue types and custom fields, like select lists, between these different Jira instances?
Enter Exalate, a synchronization solution that helps map and sync various fields between multiple Jira deployments.
Let’s dive in and see how!
- The Use Case
- Exalate: a Customizable Integration Solution
- How to Sync Issue Types and Select Lists Between Jira Cloud and Jira On-premise
The Use Case
The Jira cloud and on-premise instances must pass the following issue information:
- Summary, description, labels, comments, and attachments must be synced bi-directionally.
- Issue types must be mapped and synced bi-directionally. So if an issue type in one instance is a Task, it must become an Incident in the other Jira instance. And if the issue type is Bug, then it must be a Change in the other system.
- Custom fields such as select lists, aka dropdowns, must be synced bi-directionally.
Basic issue fields like summary, description, etc are easy to sync. The real challenge is to map the issue types in the two instances and sync them properly. The same mapping logic must apply to the select list entries as well.
If a user selects a particular item from the list, the other instances’ list must reflect the correct item.
Let’s take a look at why Exalate excels in a use case like this.
Exalate: a Customizable Integration Solution
Exalate is a highly customizable integration solution to synchronize data across multiple platforms like Jira, ServiceNow, Zendesk, Salesforce, Azure DevOps, GitHub, etc.
With Exalate, you can control your sync at a granular level and automate the information flow based on the native query languages of the platform you use.
Some key features of Exalate are:
- Customizability: Exalate provides flexible configuration options, allowing teams to define their sync rules, filters, mappings, and workflows. Such customization ensures that the integration meets the specific needs and requirements of each team.
- Security and Control: Exalate prioritizes security and provides features such as encrypted communication, access controls, and audit logs. This ensures that sensitive data remains secure during the synchronization process.
- Scalability: Exalate is designed to handle large volumes of data and can scale according to the needs of your organization. It supports synchronization between multiple projects, teams, and even different companies.
How to Sync Issue Types and Select Lists Between Jira Cloud and Jira On-premise
Then connect Jira instances using the Script mode.
After establishing the connection, click on the “Configure Sync” button. You’ll be redirected to the “Rules” tab. You can decide what information you want to send and receive between the platforms using the “Rules” tab.
Exalate provides two sets of script windows in both the Jira instances. The “Outgoing sync” defines what data must go out from the particular Jira instance. And the “Incoming sync” defines how to interpret data coming from the other Jira instance.
Map and Sync Issue Types
Next, you must map the issue types between the platforms. You can perform this mapping at either of the ‘Incoming sync’ script windows, depending on your requirement.
In this use case, we will create a Task or a Bug in Jira Cloud, and it should be reflected as an Incident or a Change in the Jira on-premise instance. So, when you create and sync an issue for the first time, a corresponding Incident or Change will be created in the other instance based on the mapping you have set.
You can also apply the same logic if the issue type is updated by creating a new mapping and mentioning it under the (!firstSync) condition. The firstSync variable determines if the issue is synced for the first time or not.
As seen in the code, a typeMap variable stores the mapping. It’s in the format remoteissuetype:localissuetype.
Then we call the getIssueType method of the nodeHelper class of Exalate. This method allows you to fetch the issue type of the replica.
Note: The replica carries the information to be passed between the systems, serving as the payload.
The getIssueType method picks up the local issue type that we have populated with the help of a map variable: typeMap, and assigns it to the issue type in Jira on-premise.
A fallback value is also assigned to the issue type if none of the values match. In our case, the fallback value is Task, but it can be any other value of your choice.
Note: We have shown a uni-directional sync here, but it can be bi-directional as well.
Sync Select Lists (Dropdown)
Select lists, also called dropdowns, are user-defined fields that allow you to select specific values from a list. These are called custom fields in the Exalate context.
To ensure that the information in the custom field is synced to the destination instance, you only need to add a single line of code.
For instance, we have a dropdown called ‘Support Group’ that holds multiple values like IT, HR, Finance, etc. When the user selects “IT” in one of the Jira instances, the corresponding value will be displayed in the other system.
Remember, just like you mapped the different issue types, you can also set up custom mappings for syncing select lists.
When a Task is created in the Jira Cloud instance, an Incident is created in the Jira on-premise instance.
Likewise, the support group “Finance” selected in the Jira Cloud instance correctly reflects the value in the Jira on-premise instance.
By integrating platforms, modern businesses stay competitive and responsive to customer needs. This use case we demonstrated is just one example of how integration tools can enable collaboration between teams.
Curious to know if Exalate is the right solution for your business? It’s just a click away!