Content Comparison

☝🏼 NOTE: We recommend running ScriptRunner scripts only for issues without multiple checklist tabs, as they may not work correctly when tabs are present.

import org.apache.log4j.Logger

// Set up logging
def log = Logger.getLogger("com.atlassian.jira.customfield")
log.setLevel(org.apache.log4j.Level.DEBUG)

// Get the custom field value
def checklistCF = cfValues["Smart Checklist"]

if (!checklistCF) {
    log.debug("Custom field value is empty or null")
    return true
}

def checklists = checklistCF._items
// Iterate through checklist items
for (item in checklists[0]) {
    log.debug("Validating item: ${item.value} - ${item.status.statusState}")
    if (item.value.equals("RTL Fix") || item.value.contains("Quality Check")) {
          if (!item.status.statusState.toString().equals("CHECKED")) {    
            log.debug("Item '${item.value}' has status '${item.status.statusState}' which is not checked.")
            // No need to continue checking, we already found one item with status not checked
            return false
        }
    }
}
log.debug("All required checklist items are marked as completed or not present")
return true

import com.atlassian.jira.component.ComponentAccessor
import com.atlassian.jira.issue.CustomFieldManager
import com.atlassian.jira.issue.Issue
import com.atlassian.jira.event.issue.IssueEvent
import org.apache.log4j.Logger
import com.atlassian.jira.workflow.TransitionOptions
import com.atlassian.jira.bc.issue.IssueService
import com.atlassian.jira.issue.IssueInputParameters
import com.atlassian.jira.workflow.WorkflowTransitionUtil
import com.atlassian.jira.issue.IssueInputParametersImpl

// Initialize log4j logger
def log = Logger.getLogger("com.acme.LogCustomFields")
log.setLevel(org.apache.log4j.Level.DEBUG)
CustomFieldManager customFieldManager = ComponentAccessor.getCustomFieldManager()
IssueEvent issueEvent = event as IssueEvent
Issue issue = issueEvent.getIssue()
def changeLog = issueEvent.getChangeLog()
def changeItems = changeLog.getRelated("ChildChangeItem")

// Function to transition issue to "TO DO"
def transitionIssueToDo(Issue issue, Logger log) {
    def issueService = ComponentAccessor.getIssueService()
    def user = ComponentAccessor.jiraAuthenticationContext.loggedInUser
    def transitionName = "To Do" ////  --- SET HERE STATUS TO BE TRANSITIONED TO IF UNCHECK ITEM
    def actionId = null

    def workflow = ComponentAccessor.getWorkflowManager().getWorkflow(issue)
    def actions = workflow.getAllActions()
    actions.each { action ->
        if (action.name == transitionName) {
            actionId = action.id
        }
    }

    if (actionId) {
        def currentUser = ComponentAccessor.getJiraAuthenticationContext().getLoggedInUser()

        def transitionValidationResult = issueService.validateTransition(currentUser, issue.id, actionId, new IssueInputParametersImpl())

        if (transitionValidationResult.isValid()) {
            transitionResult = issueService.transition(currentUser, transitionValidationResult)
            if (transitionResult.isValid()) { 
                log.debug("Transitioned issue $issue through action $actionId") 
            } else { 
                log.debug("Transition result is not valid  Details: ${transitionResult.errorCollection}") 
            }
        } else {
            log.debug("The transitionValidation is not valid")
        }
    } else {
        log.error("Transition to 'To Do' not found")
    }
}

// Check if any of the custom fields were changed
changeItems.each { changeItem ->
    def fieldName = changeItem.getString("field")
    if(fieldName.equals("Checklists")){ // DONOT CHANGE 'Checklists'
        def theCustomFieldObject = "Smart Checklist" // DONOT CHANGE "Smart Checklist"
        def customFieldList = customFieldManager.getCustomFieldObjectsByName(theCustomFieldObject)
        if (customFieldList && !customFieldList.isEmpty()) {
            def customField = customFieldList.first()
            def fieldValue = issue.getCustomFieldValue(customField)

            def items = fieldValue[0]._items

            for(item in items){
                log.debug("Validating item: ${item.value} - ${item.status.statusState}")
                if (item.value.equals("RTL Fix") || item.value.contains("Quality Check")) { // REPLACE WITH SPECIFIC ITEMs
                    if (!item.status.statusState.toString().equals("CHECKED")) {    
                        log.debug("Item '${item.value}' has status '${item.status.statusState}' which is not checked.")
                        transitionIssueToDo(issue, log)
                        break
                    }
                }    
            }
        } else {
            log.debug("Custom field with name $theCustomFieldObject not found")
        }
   }
}

import com.atlassian.jira.component.ComponentAccessor
import com.atlassian.jira.issue.Issue
import com.atlassian.jira.issue.CustomFieldManager
import com.atlassian.jira.event.issue.IssueEvent
import com.atlassian.jira.issue.fields.CustomField
import com.atlassian.jira.issue.MutableIssue
import com.atlassian.jira.issue.util.DefaultIssueChangeHolder
import com.atlassian.jira.bc.issue.IssueService
import com.atlassian.jira.bc.issue.IssueService.CreateValidationResult
import com.atlassian.jira.bc.issue.IssueService.IssueResult
import com.atlassian.jira.issue.IssueInputParameters
import com.atlassian.jira.issue.IssueInputParametersImpl
import com.atlassian.jira.issue.ModifiedValue
import com.atlassian.jira.issue.issuetype.IssueType
import org.apache.log4j.Logger
import com.atlassian.jira.issue.link.IssueLinkManager
import com.atlassian.jira.issue.link.IssueLinkType
import com.atlassian.jira.issue.link.IssueLink
import com.atlassian.jira.issue.link.IssueLinkTypeManager


// Initialize log4j logger
def log = Logger.getLogger("com.acme.LogCustomFields")
log.setLevel(org.apache.log4j.Level.DEBUG)

CustomFieldManager customFieldManager = ComponentAccessor.getCustomFieldManager()
IssueEvent issueEvent = event as IssueEvent
Issue issue = issueEvent.getIssue()
def changeLog = issueEvent.getChangeLog()
def changeItems = changeLog.getRelated("ChildChangeItem")

// IssueService for creating sub-tasks
IssueService issueService = ComponentAccessor.getIssueService()
def user = ComponentAccessor.getJiraAuthenticationContext().getLoggedInUser()

// Get all sub-tasks of the current issue
def subTasks = issue.getSubTaskObjects().collect { it.getSummary() }


// Check if any of the custom fields were changed
changeItems.each { changeItem ->
    def fieldName = changeItem.getString("field")
    
    if (fieldName.equals("Checklists")) {  // DONOT CHANGE 'Checklists'
        def theCustomFieldObject = "Smart Checklist"  // DONOT CHANGE "Smart Checklist"
        def customFieldList = customFieldManager.getCustomFieldObjectsByName(theCustomFieldObject)
        
        if (customFieldList && !customFieldList.isEmpty()) {
            def customField = customFieldList.first()
            def fieldValue = issue.getCustomFieldValue(customField)
            def items = fieldValue[0]._items  // The list of checklist items

            for (item in items) {
                def itemValue = item.value
                log.debug("Validating item: ${itemValue} ")

                // Create sub-task only if it's a new item (not in existing sub-tasks)
                if (!subTasks.contains(itemValue)) {
                    log.debug("Creating sub-task for new item: ${itemValue}")

                    def issueTypeManager = ComponentAccessor.getConstantsManager().getAllIssueTypeObjects()
                        
                        // Look for the issue type named "Sub-task"
                    IssueType subTaskIssueType = issueTypeManager.find { it.isSubTask() }
                    

                    log.debug("Issue type ${subTaskIssueType} ");
                        
                    IssueInputParameters issueInputParameters = issueService.newIssueInputParameters()
                        issueInputParameters.setSummary(itemValue)
                            .setIssueTypeId(subTaskIssueType.id)  // Retrieve the Sub-task issue type ID
                            .setReporterId(user.getName())  // Set the reporter to the user who triggered the action
                            .setProjectId(issue.getProjectId())
                            .setAssigneeId(issue.getAssigneeId())

                        // Validate sub-task creation
                        IssueService.CreateValidationResult validationResult = issueService.validateSubTaskCreate(user, issue.getId(), issueInputParameters)
                        
                        if (validationResult.isValid()) {
                            IssueService.IssueResult createResult = issueService.create(user, validationResult)
                            

                            
                            if (createResult.isValid()) {
                                def subTask = createResult.issue

                                
                                IssueLinkManager issueLinkManager = ComponentAccessor.getIssueLinkManager()
                                Collection<IssueLink> issueLinks = issueLinkManager.getIssueLinks(issue.getId())
                                int maxSequence = 0

                                // Iterate through the collection to find the maximum sequence
                                issueLinks.each { issueLink ->
                                    // Get the sequence for the current issue link
                                    int sequence = issueLink.getSequence() ?: 0

                                    // Update the max sequence if the current one is greater
                                    if (sequence > maxSequence) {
                                        maxSequence = sequence
                                    }
                                }

                                // Output the maximum sequence
                                log.debug("The maximum sequence value is: ${maxSequence}")

                                // You can also use maxSequence + 1 if needed
                                int nextSequence = maxSequence + 1
                                def issueLinkTypeManager = ComponentAccessor.getComponent(com.atlassian.jira.issue.link.IssueLinkTypeManager)
                                // Get all issue link types
                                Collection<IssueLinkType> issueLinkTypes = issueLinkTypeManager.getIssueLinkTypes(false)
                                def matchingLinkType = issueLinkTypes.find { it.name == "jira_subtask_link" }
                                issueLinkManager.createIssueLink(issue.getId(), subTask.id, matchingLinkType.id, nextSequence, user)
                            } else {
                                log.error("Failed to create sub-task: ${createResult.errorCollection}")
                            }
                        } else {
                            log.error("Sub-task validation failed: ${validationResult.errorCollection}")
                        }
                } else {
                    log.debug("Sub-task for item: ${itemValue} already exists, skipping creation")
                }
            }
        } else {
            log.debug("Custom field with name $theCustomFieldObject not found")
        }
    }
}

import com.atlassian.jira.component.ComponentAccessor
import groovyx.net.http.RESTClient
import com.atlassian.jira.issue.fields.CustomField
import com.atlassian.jira.issue.CustomFieldManager


def username = 'username'  // Replace with actual username or read value from system environments
def password = 'password'    // Replace with actual password or read value from system environments
def apiUrl = 'jira instance url' // Replace with your domain
def markAsDownPath = '/rest/railsware/1.internal/checklist/markAsDone' // might be needed to add /jira at the begining
def customFieldName = "Smart Checklist"

if (!issue) {
    log.error("Issue not found in transient variables.")
    return "Issue not found"
}

log.info("Issue details: ${issue.key}, Status: ${issue.status.name}")

def doneStatus = ComponentAccessor.constantsManager.getStatusByName("Done")
def resolvedStatus = ComponentAccessor.constantsManager.getStatusByName("Resolved")

if (issue.status.id == doneStatus.id || issue.status.id == resolvedStatus.id) {
    log.debug("Issue ${issue.key} is now in ${issue.status.name} status. Updating checklist items.")
    try {
        CustomFieldManager customFieldManager = ComponentAccessor.getCustomFieldManager()
        CustomField customField = customFieldManager.getCustomFieldObjectByName(customFieldName)
        
        def authString = "${username}:${password}".bytes.encodeBase64().toString()

        if (!customField) {
            log.error("Custom field '${customFieldName}' not found.")
            return "Custom field not found"
        }

        def checklists = issue.getCustomFieldValue(customField)

        if (!checklists || checklists.isEmpty()) {
            log.warn("No checklists found for issue ${issue.key}.")
            return "No checklists found"
        }

        def restClient = new RESTClient(apiUrl)
        checklists.forEach { checklist ->
            log.info("Fetching: ${apiUrl}/jira/rest/railsware/1.internal/checklist/markAsDone?checklistId=${checklist.id}")


            def response = restClient.put(
                path: markAsDownPath,
                query: [checklistId: checklist.id],
                contentType: 'application/json',
                headers: [Authorization: "Basic ${authString}"]

            )

            if (response.status > 200 && response.status < 300 ) {
                log.info("Successfully marked checklist ID ${checklist.id} as done.")
            } else {
                log.error("Failed to mark checklist ID ${checklist.id}. Response: ${response.status} - ${response.data}")
            }
        }
    } catch (Exception e) {
        log.error("Exception occurred while updating checklists: ${e.message}", e)
    }
} else {
    log.info("Issue ${issue.key} is not in Done or Resolved status. No action taken.")
}

import com.atlassian.jira.issue.ModifiedValue
import com.atlassian.jira.issue.util.DefaultIssueChangeHolder
import com.atlassian.jira.component.ComponentAccessor
import com.atlassian.jira.issue.fields.CustomField
import com.atlassian.jira.issue.MutableIssue
import org.apache.log4j.Logger
import groovyx.net.http.RESTClient
import groovy.json.JsonOutput

// Initialize log4j logger
def log = Logger.getLogger("com.acme.UpdateChecklistItem")
log.setLevel(org.apache.log4j.Level.DEBUG)

def customFieldManager = ComponentAccessor.getCustomFieldManager()
def issueManager = ComponentAccessor.getIssueManager()
def issue = transientVars.get("issue") as MutableIssue //USE THIS FOR POSTFUNCTIONS

def authString = "Personal Access Token" // Add Personal Access Token
def apiUrl = 'Jira_base_url' // Replace with your domain
def updateChecklistPath = 'rest/railsware/1.internal/checklist' // might be needed to add /jira at the begining
def requiredValues = ["Task A", "Task B", "Task C"]   // Here are the values you want to mark as mandatory


def CUSTOM_FIELD_NAME = "Smart Checklist" // DONOT CHANGE THIS

CustomField customField = customFieldManager.getCustomFieldObjectsByName(CUSTOM_FIELD_NAME)?.first()

if (!customField) {
    log.debug("Custom field '$CUSTOM_FIELD_NAME' not found")
    return
}


def currentChecklist = issue.getCustomFieldValue(customField)

if(!currentChecklist){
    log.debug("No checklist found for issue")
    return;
}

def restClient = new RESTClient(apiUrl)

for (checklist in currentChecklist) {
    def items = checklist._items 

    def matchingItemIds = items.findAll { requiredValues.contains(it.value) }*.id
    
    if (matchingItemIds) {
        def requestBody = matchingItemIds.collect { id ->
            [
                id   : id,
                mandatory : true
            ]
        }


        def jsonPayload = JsonOutput.toJson(requestBody)


        log.debug("URL: ${apiUrl}/${updateChecklistPath}/${checklist.id}")
        log.debug("body: ${jsonPayload}")
        try {
            def response = restClient.put(
                path: "${apiUrl}/${updateChecklistPath}/${checklist.id}",
                body: jsonPayload,
                requestContentType: 'application/json',
                headers: [Authorization: "Bearer ${authString}"]
            )

            log.debug("Response Code: ${response.status}")
            log.debug("Response: ${response.data}")

        } catch (Exception e) {
            log.error("Failed to update checklist items: ${e.message}")
        }

        log.debug("Checklist custom field updated successfully!")
    } else {
        log.debug("No checklist items matched the filter condition.")
    }
}

💡HINT: To get the Personal Access Token navigate to User icon → Profile → Personal Access Tokens → Create Token

Image Added