Discrepancy between Jira link types available on the UI and those returned by the Jira REST API

[Rhea Kokila]

Hi, everyone,

I've encountered a situation wherein the Jira link types that I see on the UI ('is implemented by', 'duplicates', 'relates to', etc.) are not at all the same as the Jira link types that I get back over the REST API ('Blocker', 'Blocks', 'Bonfire Testing', 'Bonfire testing', etc.).  The outward and inward descriptions of these types are different from the ones that I see on the UI.

This is the REST API I'm using (maybe this is the problem?): http://jira.readthedocs.io/en/master/api.html?highlight=link%20type#jira.JIRA.issue_link_types

Because the link types that the REST API returns aren't entirely familiar with what we're used to seeing on the UI this is preventing me from creating a Jira linking feature on our tool.

When I contacted our Jira admins that maintain the Jira instances at work, they suggested that Atlassian does not always guarantee parity between what is available over the UI and what is returned over the REST API.

I'd like to ask the wider community if there's anything that can be done to ensure that the Jira link types that the REST API returns are the same as the ones that we see on the UI, such as a version update or some tinkering around with the Admin settings.

Thanks in advance! 

[Sam Hall · Accepted solution]

Hi Rhea - the docs you linked aren't the JIRA REST API docs, they are the docs for JIRA Python Library, which is a popular Python library that interfaces with the JIRA REST API and simplifies the use of it.

These are the links to the actual JIRA REST APIs docs in case they are helpful:

For JIRA Server: https://docs.atlassian.com/jira/REST/server/

For JIRA Cloud: https://docs.atlassian.com/jira/REST/cloud/

[Sam Hall]

If you are using the JIRA Python Library, rather than making calls directly to the JIRA REST API, there's a chance that that the use of the library is confisuing matters in some way.

I'd recommend trying some direct requests to the JIRA REST API without using the library to check that it really isn't returning what you expect.

This is an example of a GET request to the JIRA REST API which will diplay issue link information:

https://jira.atlassian.com/rest/api/latest/issue/JRASERVER-9?fields=summary,issuelinks

This returns information from Atlassian's public issue tracker (jira.atlassian.com), just to demonstrate.

Compare the data returned with actual issue viewed through the UI: https://jira.atlassian.com/browse/JRASERVER-9

Note that the REST API returns full information about the link:

id: "27174",
self: "https://jira.atlassian.com/rest/api/2/issueLink/27174",
type: {
   id: "10000",
   name: "Reference",
   inward: "is related to",
   outward: "relates to",
   self: "https://jira.atlassian.com/rest/api/2/issueLinkType/10000"
},
outwardIssue: {
   id: "39309",
   key: "JRASERVER-10613",
   self: "https://jira.atlassian.com/rest/api/2/issue/39309",
   fields: {...}
}

Wheras the UI displays the only the 'inward' or 'outward' name depending the direction of the link.

You can tell this from the API data by looking at the whether the issuelink shows an inwardIssue or an outwardIssue. 

In the example above, it's an outwardIssue, so the UI displays the outward text, i.e. "relates to":

You can do try the same GET request for an issue on your JIRA instance to look at the details and hopefully this will explain it.

[Sam Hall]

If you still find descrepancies, reply with a snippet of the REST API response and a screenshot like I did above.

That'll help the community see clearly what the problem is. If you do that, I'm sure someone will be able to help further.

[Rhea Kokila]

Hi, Sam,

Thanks so much for your detailed response.

Tinkering around with the GET request that you proposed, I was able to hit our Jira server and retreive the list of available link types.

<http://host:port/context>/rest/api/2/issueLinkType

It appears that I was a bit over-hasty in determining that there was a discrepency.  It looks like I just didn't understand this concept well enough.

The link types returned by the GET request and the Python Library request were, in fact, the same.  

However, I was naively expecting to see the returned link type names align with the link types available over the UI.  Instead, It looks like the link types available over the UI correspond to the set of all inward and outward descriptions of the returned link types.  

I was able to see this clearly when I wrote down all the inward and outward descriptions for the link types that were returned and compared that list against what I was seeing on the UI.

Thanks for reminding me about hitting the Jira instance server through a simple GET request.  I was able to cross-check the Python link types with the server link types, which was really helpful.

Cheers! 

[Sam Hall]

Great stuff. I'm glad I helped. Thanks for taking the time to accept the answer and write up how you worked it out.

It really helps others in the community with the same trouble in future.

[Steven F Behnke]

It seems like Sam got you the help you need, but I wanted to clear something up.

There is a Type of link, these are types like -- 

• Relates
• Cloners
• Blocks
• Duplicate

Links have directions, inward and outward. The descriptions are indicative of the direction of the link --

Outward / Inward

• relates to / relates to
• clones / is cloned by
• blocks / is blocked by
• duplicates / is duplicated by

This is so you can definitively say --

• X issue clones Y issue == Y issue is cloned by X issue
• X issue blocks Y issue == Y issue is blocked by X issue

The directions aren't always important. For instance, Relates linktype. The direction descriptions are the same. However, you'd still need to get all Outward and Inward links and parse for the type.