List of Jira fields and description

[Robert Ogden]

My team is currently moving from one application to JIRA - currently we utilize the other application as a requirements repository and I am looking to see if I can match up the fields between this application and JIRA.  Looking to get a listing of default fields types and a description and possible restriction.

Example would be Summary / required field maximum of 255 characters

Any help would be greatly appreciated

[Mykenna Cepek · Accepted solution]

This is a great question that is, unfortunately, not served by any current documentation.

It's also a difficult question to definitively answer. Hopefully you don't need a perfect answer!

I looked at a fairly recently created instance of Jira Cloud that we have. I started with the full Field Configuration list, and removed any Custom Fields and internal Jira fields.

Then I made my best guesses as to field type and mandatory fields (noted with an asterisk *). So this is a quick, rough guess based on my 10+ years of Jira experience. Maybe others can chime in about what I got wrong.

Note that the multiline markup text fields don't have any appreciable character limit. Other text fields are likely 255 (I only tested the Summary field).

Hopefully this will be enough to get you moving towards an import from your other system. I've not done many imports (and haven't for quite a while), so I won't be much help there. Try importing one, or a few, and see how that goes; then import the bulk.

Affects versions - version picker

Assignee - user picker *

Comment - multiline markup text

Components - component picker

Description - multiline markup text

Due date - date field

Environment - markup text

Epic Link - issue picker

Epic Name - simple text field

Fix versions - version picker

Flagged - boolean

Issue Type - issue type picker *

Labels - label picker

Linked Issues - issue picker

Priority - priority picker

Reporter - user picker *

Resolution - resolution picker

Security Level - security level picker

Sprint - sprint picker

Start date - date field

Story Points - numeric

Story point estimate - numeric

Summary - markup text (255 chrs max)

Target end - date picker

Target start - date picker

Team - team picker

[Robert Ogden]

Mykenna

This is a perfect start and appreciate  you putting this together - it has been about five years since I last administered or even developed a project within JIRA - but great thing is that its like riding a bike you never forget how to do it.

We are currently playing around in a sandbox before we move or create anything in our Prod environment - we are migrating off an application called Blueprint that we only use as a requirements repository - currently have over 5k requirements that we have distributed between different workstreams that we reuse for all existing and new projects to create traceability. 

Again thank you so much for the response and I truly appreciate it.

Thanks

Rob

[Oliver Siebenmarck _Polymetis Apps_]

Hi @Robert Ogden

There is also a slightly experimental and more techie option using the REST API and Jira Expressions. If you are technically inclined (or have a dev nearby), read on.

Using the Analyse Jira expression endpoint you can check the type that an expressions evaluates to. You can also use it to send it a bunch of single field expressions and get their types back. For example, sending this:

{ "expressions": 
  [ 
    "issue.summary", 
    "issue.description", 
    "issue.priority",
    "issue.customfield_10100"
  ]
}

Yields this result:

{ "results": [
  {
   "expression": "issue.summary",
   "valid": true,
   "type": "String"
  },
  {
   "expression": "issue.description",
   "valid": true,
   "type": "RichText"
  },
  {
   "expression": "issue.priority",
   "valid": true,
   "type": "IssuePriority"
  },
  {
   "expression": "issue.customfield_10100",
   "valid": true,
   "type": "String"
  }
 ]}

The cool thing is, that you get the actual type that Jira uses for a field and you can get the types of all your custom fields as well. 

Hope that helps, let me know if you have any more questions about this approach. Jira Expressions are a bit of a hobby of me.

Cheers,
  Oliver

[Mykenna Cepek]

For the extra-curious, here is the full result using Jira Expressions REST API that @Oliver Siebenmarck _Polymetis Apps_ suggested above:

assignee - User
attachments - List<Attachment>
changelogs - List<Changelog>
closedSprints - List<Sprint>
color - String
comments - List<Comment>
components - List<Component>
created - Date
creator - User
description - RichText
done - Boolean
dueDate - CalendarDate
environment - RichText
epic - Issue
fixVersions - List<Version>
flagged - Boolean
id - Number
isEpic - Boolean
issueType - IssueType
key - String
labels - List<String>
links - List<IssueLink>
name - String
originalEstimate - Number
parent - Issue
priority - IssuePriority
project - Project
properties - EntityProperties
remainingEstimate - Number
reporter - User
resolution - Resolution
resolutionDate - Date
securityLevel - SecurityLevel
sprint - Sprint
status - IssueStatus
stories - List<Issue>
subtasks - List<Issue>
summary - String
timeSpent - Number
updated - Date
versions - List<Version>

Note that this list includes everything supported by that API call, including many fields which are internal to Jira (like changelogs and parent).

[Mykenna Cepek]

And for full extra-credit, here is the Python I used to get the raw data leading to the cleaned-up list above:

import requests
from requests.auth import HTTPBasicAuth
import json

url = 'https://kinectconsulting.atlassian.net/rest/api/2/expression/analyse'

auth = HTTPBasicAuth("username@yourinstance.com", "YourJiraTokenGoesHere")

headers = {
"Accept": "application/json",
"Content-Type": "application/json"
}

payload = json.dumps( {
"contextVariables": {
"listOfStrings": "List<String>",
"record": "{ a: Number, b: String }",
"value": "User"
},
"expressions": [
"issue.assignee",
"issue.attachments",
"issue.changelogs",
"issue.closedSprints",
"issue.color",
"issue.comments",
"issue.components",
"issue.created",
"issue.creator",
"issue.description",
"issue.done",
"issue.dueDate",
"issue.environment",
"issue.epic",
"issue.fixVersions",
"issue.flagged",
"issue.id",
"issue.isEpic",
"issue.issueType",
"issue.key",
"issue.labels",
"issue.links",
"issue.name",
"issue.originalEstimate",
"issue.parent",
"issue.priority",
"issue.project",
"issue.properties",
"issue.remainingEstimate",
"issue.reporter",
"issue.resolution",
"issue.resolutionDate",
"issue.securityLevel",
"issue.sprint",
"issue.status",
"issue.stories",
"issue.subtasks",
"issue.summary",
"issue.timeSpent",
"issue.updated",
"issue.versions"
]
} )

parameters = {'check':'type'}

response = requests.request(
"POST",
url,
params=parameters,
data=payload,
headers=headers,
auth=auth
)

print("Response.status_code =", response.status_code)
print(json.dumps(json.loads(response.text), sort_keys=True, indent=4, separators=(",", ": ")))

The API produced the list of issue keys (in an error message) when I provided an unsupported key.

[Ramiz Ballou]

Hello,

I am new to JIRA Admin and designing many my foundation and creating few customs  (i.e Schemes for fields, screens, permissions...).

There are number of fields to choose from for screens but not sure what they mean or how to pick them up: e.g. Development, environment,...etc). is there and description for what do these really mean? or they are just place holder to filled for the specific project?