Example Custom Scripts

List labels = issue.fields.labels ?: [] // get the labels for the current item
labels += "newLabel"
issueInput.fields.labels = labels

def issueHapi = Issues.getByKey(issue.key)
def linkedIssues = issueHapi.getLinkedIssues()
 
// Loop through the linked work items to add a comment to inward work items
linkedIssues.each { linkedIssue ->
    linkedIssue.comment("Parent issue ${issue.key} has been transitioned to ${issueHapi.getStatus().name}.")
}

// Define a counter which will be the number of support tickets updated by this script
def counter = 0
 
// Define the Service Desk Issuetypes you only want updated if a linked Jira software work item is closed
def serviceDeskIssueTypes = [
 "Incident",
 "Feature Request"
]
 
def issueHapi = Issues.getByKey(issue.key)
def linkedIssues = issueHapi.getLinkedIssues()
 
// Loop over each linked issue
linkedIssues.each { linkedIssue ->
 // For each linked issue, comment only on Service Desk Tickets
 if (serviceDeskIssueTypes.contains(linkedIssue.getIssueType().name)) {
        linkedIssue.comment("""
            Good news! We've now completed the development work related to this ticket.
 """)
        counter++
 // Log info about which Service Desk ticket was just updated
        logger.info("Issue ${issue.key} has been closed. 
Service Desk ticket ${linkedIssue.getKey()} has been commented to inform affected customers.")
    }
}
 
return "The script finished successfully. ${counter} support ticket/s were commented on.

**Note:** Service Desk API calls don't have HAPI equivalents, so this remains as REST API.
 
def serviceDeskId = "2"
def issueHapi = Issues.getByKey(issue.key)
def currentUser = issueHapi.getReporter().accountId
 
// Get the Custom field to get the option value from
def organisationCustomField = get("/rest/api/2/field")
    .asObject(List)
    .body
    .find { (it as Map).name == "Organisation" } as Map
 
assert organisationCustomField
 
def organisationValue = issueHapi.getCustomFieldValue(organisationCustomField.id)?.value
 
def organisations = get("rest/servicedeskapi/servicedesk/${serviceDeskId}/organization")
    .asObject(Map)
 
assert organisations
 
def organisationsValues = organisations.body.values
 
switch (organisationValue) {
 case "Adaptavist":
 def adaptavistId = organisationsValues.find { (it as Map).name == "Adaptavist" } as Map
        addToOrganisation(adaptavistId, currentUser)
 break
 case "Google":
 def googleId = organisationsValues.find { (it as Map).name == "Google" } as Map
        addToOrganisation(googleId, currentUser)
 break
 case "Atlassian":
 def atlassianId = organisationsValues.find { (it as Map).name == "Atlassian" } as Map
        addToOrganisation(atlassianId, currentUser)
 break
 default:
        logger.info("No matching organisation specified.")
 break
}
 
// Utility method for handling all the logic to add users to an organisation
def addToOrganisation(Map organisation, currentUser) {
 def currentUsersInOrganistion = get("/rest/servicedeskapi/organization/${organisation.id}/user")
        .asObject(Map)
        .body
        .values
 
 if (currentUser in currentUsersInOrganistion.accountId) {
        logger.info("User already in organisation, script terminating.")
 return
    }
 
 def addToOrganisation = post("rest/servicedeskapi/organization/${organisation.id}/user")
        .header("Content-Type", "application/json")
        .body([
            accountIds: [currentUser],
            organisationId: organisation.id
        ])
        .asObject(Map)
 
 assert addToOrganisation.status >= 200 && addToOrganisation.status <= 300
}

// Get all subtasks below a work item
def jqlQuery = "parent=${issue.key}"
 
// Specify the name below for the global Done transition
def doneTransitionName = "Done"
 
// Get all subtask issues for the current work item
def allSubtasks = Issues.search(jqlQuery)
 
/**
 * You can also get the subtasks for the desired work item in the following way
 *
 * def allSubtasks = Issues.getByKey(issue.key).getSubtasks()
 */
 
// Iterate over each subtask returned
allSubtasks.each { subtask ->
    subtask.transition(doneTransitionName)
}

def issueHapi = Issues.getByKey(issue.key)
 
// Get custom field values using HAPI
def input1 = issueHapi.getCustomFieldValue('Custom Field 1') as Integer
def input2 = issueHapi.getCustomFieldValue('Custom Field 2') as Integer
 
if (input1 == null || input2 == null) { 
    logger.info("Calculation using ${input1} and ${input2} was not possible")
 return
}
 
def output = input1 + input2
def currentOutput = issueHapi.getCustomFieldValue('Output Custom Field') as Integer
 
if (output == currentOutput) { 
    logger.info("already been updated")
 return
}
 
issueHapi.update {
    setCustomFieldValue('Output Custom Field', output)
}

issue.fields.assignee != null

// Specify the key of the space to create the work in.
def projectKey = "Demo"
 
// Specify the name of the Bug work type
def bugIssueType = "Bug"
 
def issueHapi = Issues.getByKey(issue.key as String)
// Get the value entered on the Service Desk ticket for Summary and Description
def serviceDeskIssueSummary = issueHapi.getSummary()
def serviceDeskIssueDescription =  issueHapi.getDescription()
 
def createdIssue =  Issues.create(projectKey, bugIssueType) {
    setSummary(serviceDeskIssueSummary)
    setDescription(serviceDeskIssueDescription)
}
 
// Create the work link between both items
issueHapi.link("relates to", createdIssue)

import java.time.LocalDateTime
import java.time.ZoneOffset
 
final projectKey = 'TEST'
//External task type name
final externalIssueTypeName = 'External Task'
//External system URL
final externalUrl = 'https://external.system'
 
//We can compute the time between epoch and one hour before now to obtain work items from external by this time.
def timestamp = LocalDateTime.now()
    .minusHours(1)
    .toInstant(ZoneOffset.UTC).toEpochMilli()
 
//We can define here the endpoint to retrieve data from the external system and the required query strings.
//In this example, we use "since" as a query string parameter, which defines the time by which we want to search.
def results = get("$externalUrl/rest/api/1/results")
    .queryString('since', timestamp)
    .asObject(List)
    .body as List<Map>
 
//For every result obtained, a new work item is created.
results.each { Map result ->
    Issues.create(projectKey, externalIssueTypeName ) {
        summary = result.name
        description = result.message
    }
}

def issueHapi = Issues.getByKey(issue.key)
def fieldsToClear = ["customfield_10047", "customfield_10007", "customfield_10040"]
 
issueHapi.update {
    fieldsToClear.each { fieldId ->
        setCustomFieldValue(fieldId, null)
    }
}

def issueHapi = Issues.getByKey(issue.key)
def targetIssue = Issues.getByKey('EX-1')
issueHapi.link("Blocks", targetIssue)

issueInput.update.labels = [[set: ["finance"]]]

final MODEL_ASSETS_CUSTOMFIELD_ID = 'customfield_12832'
final PHONES_ASSETS_CUSTOMFIELD_ID = 'customfield_12834'
final ATTRIBUTE_NAME_OF_MODEL_IN_PHONES = 'Model Name'
 
def issueHapi = Issues.getByKey(issue.key)
 
def getModelNameResponse = get('/rest/api/3/issue/' + issue.key)
    .header('Content-Type', 'application/json')
    .queryString("expand", "${MODEL_ASSETS_CUSTOMFIELD_ID}.cmdb.attributes")
    .asObject(Map)
 
assert getModelNameResponse.status == 200
 
if (!getModelNameResponse.body.fields[MODEL_ASSETS_CUSTOMFIELD_ID]) {
    logger.warn "No value in Assets field: $MODEL_ASSETS_CUSTOMFIELD_ID"
 return
}
 
def workspaceId = getModelNameResponse.body.fields[MODEL_ASSETS_CUSTOMFIELD_ID].first().workspaceId
def objectSchemaId = getModelNameResponse.body.fields[MODEL_ASSETS_CUSTOMFIELD_ID].first().objectType.objectSchemaId
def modelName = getModelNameResponse.body.fields[MODEL_ASSETS_CUSTOMFIELD_ID].first().label
 
def aql = """
 "objectSchemaId" = "$objectSchemaId" and "$ATTRIBUTE_NAME_OF_MODEL_IN_PHONES" = "$modelName"
"""
 
def aqlQueryResponse = post("https://api.atlassian.com/jsm/assets/workspace/$workspaceId/v1/object/aql")
    .header('Content-Type', 'application/json')
    .basicAuth("user@example.com", "<api_token>")
    .body([
        qlQuery: aql
    ])
    .asObject(Map)
 
assert aqlQueryResponse.status == 200
 
def matchedPhoneAssetIds = aqlQueryResponse.body.values*.globalId
 
issueHapi.update {
    setCustomFieldValue(PHONES_ASSETS_CUSTOMFIELD_ID, matchedPhoneAssetIds.collect { id -> [id: id] })
}

// this only works when there is a transition screen
Map addComment = transition.update.comment[0].add as Map
addComment.body = "${issue.key} caused this to be transitioned"