Rewriting Scripts for Cloud Hints and Tips

groovy
def fieldNameToIdMap
 
def fields = get('/rest/api/2/field')
        .header('Content-Type', 'application/json')
        .asObject(List)
if (fields.status == 200){
    fieldNameToIdMap = fields.body.collectEntries {
        [(it.name): it.id]
    }
} else {
    return "Failed to generate fields map ${fields.status} ${fields.body}"
}

groovy
/*
 For Server/DC you will not likely need to get a map of field names to ID for custom fields as you can just
 use this simple method to get a collection CustomField objects and then filter by name as shown in the next example.
*/
import com.atlassian.jira.component.ComponentAccessor

def fields = ComponentAccessor.customFieldManager.getCustomFieldObjects()

groovy
final customFieldName = 'TextFieldA'

def fieldId
def fields = get('/rest/api/2/field')
        .header('Content-Type', 'application/json')
        .asObject(List)
if (fields.status == 200){
    fieldId = fields.body.find {
        it.name == customFieldName
    }.id
} else {
    return "Failed to generate fields map ${fields.status} ${fields.body}"
}

groovy
import com.atlassian.jira.component.ComponentAccessor

final FIELD_NAME = 'TextFieldA'

def myFieldId = ComponentAccessor.customFieldManager.getCustomFieldObjects().find { it.name == FIELD_NAME }?.id

groovy
def issueKey = 'TEST-2'
 
def sendNotification = false // control if notification email is sent to all watchers
 
def fieldNameToIdMap
 
def fields = get('/rest/api/2/field')
        .header('Content-Type', 'application/json')
        .asObject(List)
if (fields.status == 200){
    fieldNameToIdMap = fields.body.collectEntries {
        [(it.name): it.id]
    }
} else {
    return "Failed to generate fields map ${fields.status} ${fields.body}"
}
 
def result = put("/rest/api/2/issue/${issueKey}")
    //.queryString("overrideScreenSecurity", Boolean.TRUE)
    .header('Content-Type', 'application/json')
    .body([
        notifyUsers: sendNotification,
        fields: [
                (fieldNameToIdMap['SelectListA']): [value: "BBB"], //Single Select List
                (fieldNameToIdMap['MultiSelectListA']): [[value: "BBBB"], [value: "CCCC"]], //Multi Select List
                (fieldNameToIdMap['RadioButtonA']): [value: "Maybe"], // Radio Buttons
                (fieldNameToIdMap['CheckBoxA']): [[value: "Maybe"], [value: "No"]], // Checkboxes
                (fieldNameToIdMap['TextFieldA']): "QWERTY", // Text Field
                (fieldNameToIdMap['UserPickerA']): ["accountId": "5b9a84022d389f762bd0bd23"], // Single User Picker
                (fieldNameToIdMap['MultiUserPickerA']): [["accountId": "5b9a84022d389f762bd0bd23"]],// Multi User Picker
                (fieldNameToIdMap['DateTimePickerA']): "2021-10-16T15:41:00.000+0100", // Date Time Field
                (fieldNameToIdMap['DatePickerA']): "2021-10-11", // Date Field
                (fieldNameToIdMap['ProjectPickerA']): [key: "TP"], // Project Picker
                (fieldNameToIdMap['LabelFieldA']): ["here", "test"], // Labels field
                (fieldNameToIdMap['VersionPickerA']): [name: "testv1"], // Single Version Picker
                (fieldNameToIdMap['MultiVersionPickerA']): [[name: "testv1"], [name: "anotherv2"]], // Multi Version Picker
                (fieldNameToIdMap['GroupPickerA']): [name: "jira-software-users-mattdevtest"], // Single Group Picker
                (fieldNameToIdMap['MultiGroupPickerA']): [ //Multi-Group Picker
                        [name:"jira-servicemanagement-users-mattdevtest"],
                        [name:"jira-software-users-mattdevtest"],
                        [name:"jira-workmanagement-users-mattdevtest"],
                ],
        ]
    ])
    .asString()
 
if (result.status == 204) {
    return 'Success'
} else {
    return "${result.status}: ${result.body}"
}

groovy
// Example taken from https://library.adaptavist.com/entity/update-the-value-of-custom-fields-through-the-script-console with added multi-version picker example
import com.atlassian.jira.component.ComponentAccessor
import com.atlassian.jira.event.type.EventDispatchOption
import com.atlassian.jira.issue.fields.CustomField
import groovy.transform.Field

// the issue key to update
@Field final String issueKey = "Test-1"

// the name of a 'single select list' custom field
final String selectList = "SelectListA"

// the name of a 'multi select list' custom field
final String multiSelectList = "MultiSelectA"

// name of a 'radio button' custom field
final String radioButtonField = "RadioButtons"

// name of a 'check box' custom field
final String checkboxField = "Checkboxes"

// the name of a 'text field' custom field
final String textField = "TextFieldA"

// the name of a 'user picker' custom field
final String userPicker = "UserPicker"

// the name of a 'multi user picker' custom field
final String multiUserPicker = "MultiUserPickerA"

// the name of a 'group picker' custom field
final String groupPicker = "GroupPicker"

// the name of a 'multi group picker' custom field
final String multiGroupPicker = "MultiGroupPicker"

// the name of a 'date and time' custom field
final String dateTimeField = "First DateTime"

// the name of a 'date' custom field
final String dateField = "Date"

// the name of a 'project picker' custom field
final String projectPickerField = "ProjectPicker"

// the name of a 'label' picker custom field
final String labelField = "LabelField"

// name of a 'single version picker' custom field
final String versionField = "VersionPicker"

// name of a 'multi version picker' custom field
final String multiVersionField = "VersionsPicker"

// change to 'true' if you want to send an email if the update is successful
final boolean sendMail = false

def issueService = ComponentAccessor.issueService
def loggedInUser = ComponentAccessor.jiraAuthenticationContext.loggedInUser
def issue = ComponentAccessor.issueManager.getIssueByCurrentKey(issueKey)

assert issue: "Could not find issue with key $issueKey"

def issueInputParameters = issueService.newIssueInputParameters().with {
    // set custom fields with options (select lists, checkboxes, radio buttons)
    addCustomFieldValue(getSingleCustomFieldByName(selectList).id, *getOptionIdsForFieldByValue(selectList, "BBB"))
    addCustomFieldValue(getSingleCustomFieldByName(multiSelectList).id, *getOptionIdsForFieldByValue(multiSelectList, "BBB", "CCC"))
    addCustomFieldValue(getSingleCustomFieldByName(radioButtonField).id, *getOptionIdsForFieldByValue(radioButtonField, "Yes"))
    addCustomFieldValue(getSingleCustomFieldByName(checkboxField).id, *getOptionIdsForFieldByValue(checkboxField, "Maybe", "Yes"))

    // set text fields
    addCustomFieldValue(getSingleCustomFieldByName(textField).id, "New Value")

    // set user fields
    addCustomFieldValue(getSingleCustomFieldByName(userPicker).id, "admin")
    addCustomFieldValue(getSingleCustomFieldByName(multiUserPicker).id, "admin", "anuser")

    // set group fields
    addCustomFieldValue(getSingleCustomFieldByName(groupPicker).id, "jira-users")
    addCustomFieldValue(getSingleCustomFieldByName(multiGroupPicker).id, "jira-users", "jira-administrators")

    // set custom field of type date
    addCustomFieldValue(getSingleCustomFieldByName(dateTimeField).id, "04/Feb/12 8:47 PM")
    addCustomFieldValue(getSingleCustomFieldByName(dateField).id, "04/Feb/12")
}

// set project picker field
def project = ComponentAccessor.projectManager.getProjectObjByKey("SSPA")
assert project: "Could not find project"
issueInputParameters.addCustomFieldValue(getSingleCustomFieldByName(projectPickerField).id, project.id.toString())

// set custom field of type label
issueInputParameters.addCustomFieldValue(getSingleCustomFieldByName(labelField).id, "foo", "bar")

// set custom field of type version picker
def versionOne = ComponentAccessor.versionManager.getVersions(issue.projectObject).findByName("Version1")
assert versionOne: "Could not find version"
issueInputParameters.addCustomFieldValue(getSingleCustomFieldByName(versionField).id, versionOne.id.toString())

// set custom field of type multi-version picker
def versionTwo = ComponentAccessor.versionManager.getVersions(issue.projectObject).findByName("Version2")
assert versionTwo: "Could not find version"
issueInputParameters.addCustomFieldValue(getSingleCustomFieldByName(multiVersionField).id, versionOne.id.toString(), versionTwo.id.toString())

def updateValidationResult = issueService.validateUpdate(loggedInUser, issue.id, issueInputParameters)
assert updateValidationResult.valid: updateValidationResult.errorCollection

def issueUpdateResult = issueService.update(loggedInUser, updateValidationResult, EventDispatchOption.ISSUE_UPDATED, sendMail)
assert issueUpdateResult.valid: issueUpdateResult.errorCollection

/**
 * Get a custom field given a custom field name.
 * If there are than one custom fields with the same name under the same Context then return the first one.
 * @param fieldName The name of the custom field
 * @param issue The issue to look for that custom field
 * @return the custom field, if that exists
 */
CustomField getSingleCustomFieldByName(String fieldName) {
    def issue = ComponentAccessor.issueManager.getIssueByCurrentKey(issueKey)
    def customField = ComponentAccessor.customFieldManager.getCustomFieldObjects(issue).findByName(fieldName)

    assert customField: "Could not find custom field with name $fieldName"
    customField
}

/**
 * Given a custom field name and option values, retrieve their ids as String
 * @param customFieldName The name of the custom field
 * @param values The values in order to get their ids
 * @return List < String >  The ids of the given values
 */
List<String> getOptionIdsForFieldByValue(String customFieldName, String... values) {
    def issue = ComponentAccessor.issueManager.getIssueByCurrentKey(issueKey)
    def customField = getSingleCustomFieldByName(customFieldName)

    ComponentAccessor.optionsManager.getOptions(customField.getRelevantConfig(issue)).findAll {
        it.value in values.toList()
    }*.optionId*.toString()
}

groovy
def query = 'project = TEST'
def searchReq = get("/rest/api/2/search")
        .queryString("jql", query)
        .asObject(Map)

assert searchReq.status == 200

// Save the search results as a Map
Map searchResult = searchReq.body

// print all the issue keys just to demonstrate what was found
searchResult.issues*.key

groovy
// Example from https://library.adaptavist.com/entity/perform-a-jql-search-in-scriptrunner-for-jira
import com.atlassian.jira.bc.issue.search.SearchService
import com.atlassian.jira.component.ComponentAccessor
import com.atlassian.jira.issue.search.SearchException
import com.atlassian.jira.web.bean.PagerFilter
import org.apache.log4j.Level

// Set log level to INFO
log.setLevel(Level.INFO)

// The JQL query you want to search with
final jqlSearch = "project = TEST"

// Some components
def user = ComponentAccessor.jiraAuthenticationContext.loggedInUser
def searchService = ComponentAccessor.getComponentOfType(SearchService)

// Parse the query
def parseResult = searchService.parseQuery(user, jqlSearch)
if (!parseResult.valid) {
    log.error('Invalid query')
    return null
}

try {
    // Perform the query to get the issues
    def results = searchService.search(user, parseResult.query, PagerFilter.unlimitedFilter)
    def issues = results.results
    issues.each {
        log.info(it.key)
    }

    issues*.key
} catch (SearchException e) {
    e.printStackTrace()
    null
}