Jenkinsfile-workflow

#!groovy
@Library("titan-library") _


// Helper method to get feature branch name
def getBranchName(currentBranch, customBranch) {
    if (currentBranch == "main" && customBranch.trim() == '') {
        echo "Error: Please provide branch name"
        fail()
    }
    def branchName = (currentBranch== 'main') ? "feature/${customBranch}" : currentBranch
    return branchName.toString();
}

pipeline {

    agent any

    tools {
        jdk "java-21"
        maven "default"
        git "git"
    }

    environment {
        TRUNK_BRANCH_NAME   = 'main'
        REPO_NAME           = "${GIT_URL.split('/')[4].split('\\.')[0]}"
        BRANCH_NAME         = "${GIT_BRANCH.startsWith('origin/') ? GIT_BRANCH['origin/'.length()..-1] : GIT_BRANCH}"
        CUSTOM_BRANCH_NAME  = " "
        MERGE_REQUEST_EXIST = false
        MERGE_REQUEST_ID    = ""
        MERGE_REQUEST_IID   = ""

        GITLAB_OWNER        = "${GIT_URL.split('/')[3]}"
        GITLAB_REPO         = "https://gitlab.tinkarbuild.com/${GITLAB_OWNER}/${REPO_NAME}.git"
        GITLAB_RELEASE_API  = "https://gitlab.tinkarbuild.com/api/v4/projects/${GITLAB_OWNER}%2F${REPO_NAME}/releases"
        GITLAB_CREDS_ID     = 'vault-gitlab-user-pat'
        GITLAB_MERGE_REQUEST_API = "https://gitlab.tinkarbuild.com/api/v4/projects/${GITLAB_OWNER}%2F${REPO_NAME}/merge_requests"
        GITLAB_GET_OPEN_MERGE_REQUESTS_API = "${GITLAB_MERGE_REQUEST_API}/?state=opened"
        TAG_VERSION          = "1.0.1"
    }


    options {
        buildDiscarder logRotator(
                daysToKeepStr: '16',
                numToKeepStr: '10'
        )

        disableConcurrentBuilds()
    }

    parameters {
        choice(name: 'action', choices: ['Select An Action', 'start', 'finish'], description: 'Build Action. Start = starts/resumes feature , Finish = ends feature. Finish - feature branch must already exist.')
        string(name: 'feature_branch', defaultValue: '', description: 'Name of branch without feature/ prefix. Must follow ABC-123_description format. ABC = JIRA prefix.')
    }

    stages {



        stage('Setup') {
            steps {
                sh """
                printenv
                echo Action ${params.action}
                """

                script {
                    pomModel = readMavenPom(file: 'pom.xml')
                    pomVersion = pomModel.getVersion()
                    isSnapshot = pomVersion.contains("-SNAPSHOT")
                    releaseVersion = pomVersion.split("-")[0]
                }
            }
        }

        stage ("Setup Parameters") {
            when {
                expression { return BRANCH_NAME.startsWith("feature/") }
                expression { return  params.action == ''}
            }

            steps{
                script {
                    parameters([
                            choice(name: 'action', choices: ['Select An Action', 'start', 'finish'], description: 'Build Action. Start = starts/resumes feature , Finish = ends feature. Finish - feature branch must already exist.'),
                            string(name: 'feature_branch', defaultValue: '', description: 'Name of branch without feature/ prefix. Must follow ABC-123_description format. ABC = JIRA prefix.')
                    ])
                }
            }
        }

        stage ("Get Branch Name"){
            when {
                expression { return params.action == 'start' || params.action == 'finish'}
            }

            steps {
                echo "Getting Branch Name"

                script {
                    def feature_name = feature_branch.replaceAll("/s", "_")
                    CUSTOM_BRANCH_NAME = getBranchName(BRANCH_NAME, feature_name)
                }
                echo "Done getting branch name: ${CUSTOM_BRANCH_NAME}"
            }
        }

        stage ('If Merge Request Exist'){
            when {
                expression { return params.action == 'start' || params.action == 'finish'}
            }

            tools {
                git 'git'
            }
            steps {
                script {
                    withCredentials([usernamePassword(credentialsId: GITLAB_CREDS_ID, passwordVariable: 'token', usernameVariable: 'user')]) {
                        echo "GitLab User ${user}"
                        echo "Check if Merge Request exists For ${CUSTOM_BRANCH_NAME}"

                        def postResponse = sh(
                                script: """
                                curl -L \
                                    -H "PRIVATE-TOKEN: ${token}" \
                                    -H "Content-Type: application/json" \
                                    -X GET \
                                    ${GITLAB_GET_OPEN_MERGE_REQUESTS_API}
                                """,
                                returnStdout: true
                        ).trim()

                        echo "Done checking if Merge Requests exists for ${CUSTOM_BRANCH_NAME}"

                        def jsonPostResponse = readJSON text: postResponse
                        for (mergeRequest in jsonPostResponse) {
                            if(mergeRequest.source_branch == "${CUSTOM_BRANCH_NAME}"){
                                MERGE_REQUEST_EXIST = true
                                MERGE_REQUEST_ID = mergeRequest.id
                                MERGE_REQUEST_IID = mergeRequest.iid
                            }
                        }
                        echo "Merge Request Exists: ${MERGE_REQUEST_EXIST}"
                    }
                }
            }
        }


        stage('Start Branch') {
            when {
                branch 'main'
                expression { return params.action == 'start' }
                expression { return params.feature_branch }
            }

            steps {
                withCredentials([gitUsernamePassword(credentialsId: GITLAB_CREDS_ID, gitToolName: 'git')]) {
                    sh """
                    git checkout main
                    git pull -p
                    git checkout -b ${CUSTOM_BRANCH_NAME}
                    mvn versions:set -DnewVersion=${releaseVersion}-${params.feature_branch}-SNAPSHOT -DgenerateBackupPoms=false
                    git commit -am "Draft: Update feature version to ${releaseVersion}-${params.feature_branch}-SNAPSHOT"
                    git push -u origin ${CUSTOM_BRANCH_NAME}
                    """
                }
            }
        }


        // Starting Stage For Feature Branch Only
        stage('Start Branch -- Feature Branch') {
            when {
                expression { return BRANCH_NAME.startsWith('feature/')}
                expression { return params.action == 'start'}
            }

            steps {
                script {
                    FEATURE_BRANCH_NAME = "${BRANCH_NAME.split("/")[1]}"
                }
                withCredentials([gitUsernamePassword(credentialsId: GITLAB_CREDS_ID, gitToolName: 'git')]) {
                    sh """
                    git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'
                    git config --get remote.origin.fetch
                    echo Start Branch -- Feature Branch
                    echo ${BRANCH_NAME}
                    git checkout ${BRANCH_NAME}
                    mvn versions:set -DnewVersion=${releaseVersion}-${FEATURE_BRANCH_NAME}-SNAPSHOT -DgenerateBackupPoms=false
                    git commit -am "Draft: Update feature version to ${releaseVersion}-${FEATURE_BRANCH_NAME}-SNAPSHOT"
                    git push origin ${BRANCH_NAME}
                    """
                }
            }
        }


        stage ('Create GitLab Merge Request'){
            when {
                expression { return params.action == 'start' }
                expression { return MERGE_REQUEST_EXIST == 'false' }
            }
            tools {
                git 'git'
            }
            steps {
                script {
                    withCredentials([usernamePassword(credentialsId: GITLAB_CREDS_ID, passwordVariable: 'token', usernameVariable: 'user')]) {
                        echo "GitLab User ${user}"
                        echo "Create Merge Request For ${CUSTOM_BRANCH_NAME}"

                        def data = "{\"title\": \"Draft: ${CUSTOM_BRANCH_NAME}\",\"source_branch\": " +
                                "\"${CUSTOM_BRANCH_NAME}\", \"description\": \"Currently work in progress for ${CUSTOM_BRANCH_NAME}\", " +
                                "\"target_branch\" : \"${TRUNK_BRANCH_NAME}\" }"

                        def postResponse = sh(
                                script: """
                                curl -L \
                                    -H "PRIVATE-TOKEN: ${token}" \
                                    -H "Content-Type: application/json" \
                                    -X POST \
                                    --data '${data}' \
                                    ${GITLAB_MERGE_REQUEST_API}
                                """,
                                returnStdout: true
                        ).trim()

                        echo "Done creating Merge Request For ${CUSTOM_BRANCH_NAME}"

                        def jsonPostResponse = readJSON text: postResponse
                        echo "${jsonPostResponse}"

                    }
                }
            }
        }


        stage('End Branch') {
            when {
                expression { return params.action == 'finish' }
            }

            steps {
                script{
                    withCredentials([gitUsernamePassword(credentialsId: GITLAB_CREDS_ID, gitToolName: 'git')]) {
                        if (MERGE_REQUEST_EXIST == 'false'){
                            echo "Error: Merge request does not exist for ${CUSTOM_BRANCH_NAME}"
                            fail()
                        }
                        def checkoutBranch = (BRANCH_NAME == 'main') ? TRUNK_BRANCH_NAME : CUSTOM_BRANCH_NAME
                        sh """
                    echo Finish Action For ${CUSTOM_BRANCH_NAME}
                    git config remote.origin.fetch '+refs/heads/*:refs/remotes/origin/*'
                    git config --get remote.origin.fetch
                    git checkout ${checkoutBranch}
                    git pull -p
                    git checkout ${CUSTOM_BRANCH_NAME}
                    mvn versions:set -DnewVersion=${releaseVersion}-SNAPSHOT -DgenerateBackupPoms=false
                    git commit -am "Branch Ready For Review - Reverted back to original snapshot version ${releaseVersion}-SNAPSHOT"
                    git push origin ${CUSTOM_BRANCH_NAME}
                    """
                    }
                }
            }
        }


        stage ('Update Merge Request'){
            when {
                expression { return params.action == 'finish' || (params.action == 'start' && BRANCH_NAME.startsWith('feature/'))}
                expression { return MERGE_REQUEST_EXIST == true}
            }
            tools {
                git 'git'
            }
            steps {
                script {
                    withCredentials([usernamePassword(credentialsId: GITLAB_CREDS_ID, passwordVariable: 'token', usernameVariable: 'user')]) {
                        echo "GitLab User ${user}"
                        echo "Updating Merge Request For ${CUSTOM_BRANCH_NAME}"

                        def mergeRequestTitle = mergeRequestDescription = "Ready For Review: ${CUSTOM_BRANCH_NAME}".toString()
                        if(params.action == 'start' && BRANCH_NAME.startsWith('feature/')){
                            mergeRequestTitle = "Draft: ${CUSTOM_BRANCH_NAME}"
                            mergeRequestDescription = "Currently work in progress for ${CUSTOM_BRANCH_NAME}"
                        }

                        def data = "{\"title\": \"${mergeRequestTitle}\", \"description\": \"${mergeRequestDescription}\"}"

                        def postResponse = sh(
                                script: """
                                curl -L \
                                    -H "PRIVATE-TOKEN: ${token}" \
                                    -H "Content-Type: application/json" \
                                    -X PUT \
                                    --data '${data}' \
                                    "https://gitlab.tinkarbuild.com/api/v4/projects/${GITLAB_OWNER}%2F${REPO_NAME}/merge_requests/${MERGE_REQUEST_IID}"
                                """,
                                returnStdout: true
                        ).trim()

                        echo "Done updating Merge Request For ${CUSTOM_BRANCH_NAME}"

                        def jsonPostResponse = readJSON text: postResponse
                        echo "${jsonPostResponse}"

                    }
                }
            }
        }


        stage('Cleanup Workspace') {

            steps {
                cleanWs()
                sh """
                echo "${env.BRANCH_NAME}"
                echo branch "${CUSTOM_BRANCH_NAME}"
                echo "${currentBuild.buildCauses}"
                """
            }
        }
    }

}