//
// CUSTOM VARIABLES (If needed, these variables can be modified, with caution, by developers.)
//

def NODEJS_VERSION = 'NodeJS 22.12.0'           // This value must first be defined in Jenkins by the DevOps team.



////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                //
//  IMPORTANT: Below this point, changes should not be made without the collaboration of DevOps.  //
//                                                                                                //
////////////////////////////////////////////////////////////////////////////////////////////////////

@Library("c2-shared-library") _

def ERROR_EMAIL_RECIPIENTS = C2_EMAIL_ERROR_NOTIFICATION   // This is stored in Jenkins System Settings
def ERROR_BUILDTEST_EMAIL_RECIPIENTS = C2_EMAIL_DEVOPS     // This is stored in Jenkins System Settings

// JENKINS VARIABLES
def JENKINS_CLIENTCONFIG_ID = "68c358c4-a26f-4eb5-a032-0f9bdf30536f"
def JENKINS_GENERALCONFIG_ID = "f7298bee-18b9-4f3e-b2c4-f5bc6369ba42"
def JENKINS_NUGET_PATH = JENKINS_GLOBAL_NUGET_PATH
def JENKINS_DXPBUILD_PATH = JENKINS_GLOBAL_DXPBUILD_PATH
def JENKINS_DXPDEPLOY_PATH = JENKINS_GLOBAL_DXPDEPLOY_PATH
def JENKINS_JIRAUPDATE_PATH = JENKINS_GLOBAL_JIRAUPDATE_2_PATH
def JENKINS_EXECUTION_TYPE = "${Project_Execution_Type}"
def JENKINS_TARGET_ENVIRONMENT = "${Project_Target_Environment}"

// INTEGRATION VARIABLES
def INTE_TARGET_NAME = 'Integration'
def INTE_JIRA_TARGET_ENV_TYPE = 'development'     // This is case sensitive and can only be one of the JIRA hard coded values.
def INTE_JIRA_DEPLOY_STATUS = ""                  // Optional Override
def INTE_ARCHIVE_ARTIFACTS = 'false'
def INTE_TEAMS_ALLOW_NOTIFICATIONS = 'true'
def INTE_YARN_COMMAND = 'build'
def INTE_DXP_API_KEY = ""                         // Populated At Runtime
def INTE_DXP_API_SECRET = ""                      // Populated At Runtime

// PREPROD VARIABLES
def PREPROD_TARGET_NAME = 'Preproduction'
def PREPROD_JIRA_TARGET_ENV_TYPE = 'staging'      // This is case sensitive and can only be one of the JIRA hard coded values.
def PREPROD_JIRA_DEPLOY_STATUS = ""               // Optional Override
def PREPROD_ARCHIVE_ARTIFACTS = 'false'
def PREPROD_TEAMS_ALLOW_NOTIFICATIONS = 'true'
def PREPROD_YARN_COMMAND = 'build'
def PREPROD_DXP_API_KEY = ""                      // Populated At Runtime
def PREPROD_DXP_API_SECRET = ""                   // Populated At Runtime

// PROD VARIABLES
def PROD_TARGET_NAME = 'Production'
def PROD_JIRA_TARGET_ENV_TYPE = 'production'      // This is case sensitive and can only be one of the JIRA hard coded values.
def PROD_JIRA_DEPLOY_STATUS = ""                  // Optional Override
def PROD_ARCHIVE_ARTIFACTS = 'false'
def PROD_TEAMS_ALLOW_NOTIFICATIONS = 'true'
def PROD_YARN_COMMAND = 'build'
def PROD_DXP_API_KEY = ""                         // Populated At Runtime
def PROD_DXP_API_SECRET = ""                      // Populated At Runtime

// BITBUCKET VARIABLES
def BITBUCKET_BRANCH_NAME = ""                    // Populated At Runtime
def BITBUCKET_COMMIT_MESSAGE = ""                 // Populated At Runtime

// DXP VARIABLES
def DXP_PROJECT_ID = ""                           // Populated At Runtime
def DXP_API_KEY = ""                              // Populated At Runtime
def DXP_API_SECRET = ""                           // Populated At Runtime
def DXP_SHOW_MAINTENANCE_PAGE = ""                // Populated At Runtime
def DXP_USE_DIRECT_DEPLOY = ""                    // Populated At Runtime
def DXP_SMOOTH_DEPLOY_MODE = ""                   // Populated At Runtime

// JIRA VARIABLES
def JIRA_CREDS_ID = JENKINS_GLOBAL_JIRACREDS_USERID
def JIRA_USERNAME = ''                            // Populated At Runtime
def JIRA_ACCESSTOKEN = ''                         // Populated At Runtime
def JIRA_POWERSHELL_COMMAND_FORMAT = ""           // Populated At Runtime
def JIRA_TARGET_ENV_TYPE = ''                     // Populated At Runtime
def JIRA_TICKET_IDS = []                          // Populated At Runtime
def JIRA_DEPLOY_STATUS = ''                       // Populated At Runtime
def JIRA_PROJECT_IDS = "CERT"
def JIRA_FIXVERSION_PREFIX = 'certinia'

// NOTIFICATION VARIABLES
def NOTIFICATION_EMAIL_FAILED_SUBJECT = ""        // Populated At Runtime
def NOTIFICATION_EMAIL_FAILED_BODY = ""           // Populated At Runtime
def NOTIFICATION_TEAMS_SUCCESS_STATUS = ""        // Populated At Runtime
def NOTIFICATION_TEAMS_SUCCESS_MESSAGE = ""       // Populated At Runtime
def NOTIFICATION_TEAMS_SUCCESS_COLOR = ""         // Populated At Runtime
def NOTIFICATION_TEAMS_FAILED_STATUS = ""         // Populated At Runtime
def NOTIFICATION_TEAMS_FAILED_MESSAGE = ""        // Populated At Runtime
def NOTIFICATION_TEAMS_FAILED_COLOR = ""          // Populated At Runtime

// MISC VARIABLES
def USE_TEST_MODE = 'false'
def USE_VERBOSE_LOGGING = 'true'
def TEAMS_WEBHOOK_URLS = ""
def TEAMS_ALLOW_NOTIFICATIONS = 'false'
def EXECUTION_TYPE_BUILD = 'build'
def EXECUTION_TYPE_BUILDTEST = 'buildtest'
def EXECUTION_TYPE_DEPLOY = 'deploy'
def EXECUTION_TYPE_DEPLOYDYNAMIC = 'dynamicdeploy'
def ARCHIVE_ARTIFACTS = 'false'
def YARN_COMMAND = "build"

if (params.Dxp_Deployment_Mode != null)
{
    if (params.Dxp_Deployment_Mode == 'Smooth Deploy - Read Only') {
        DXP_SMOOTH_DEPLOY_MODE = "readonly"
    }
    else if (params.Dxp_Deployment_Mode == 'Smooth Deploy - Read Write') {
        DXP_SMOOTH_DEPLOY_MODE = "readwrite"
    }
    else if (params.Dxp_Deployment_Mode == 'Maintenance Page') {
        DXP_SHOW_MAINTENANCE_PAGE = "true"
    }
    else {
        DXP_USE_DIRECT_DEPLOY = "true"
    }
}
else {
    DXP_USE_DIRECT_DEPLOY = "true"
}


pipeline {
    agent any
    tools {
        nodejs NODEJS_VERSION
    }
    stages {
        stage('Initialize') {
            steps {
                script {
                    logging.WriteTestModeMessage(USE_TEST_MODE == 'true')
                    
                    logging.WriteSectionMessage("Initializing Variables")
                    
                    if (JENKINS_EXECUTION_TYPE == EXECUTION_TYPE_BUILD || JENKINS_EXECUTION_TYPE == EXECUTION_TYPE_BUILDTEST || JENKINS_EXECUTION_TYPE == EXECUTION_TYPE_DEPLOY || JENKINS_EXECUTION_TYPE == EXECUTION_TYPE_DEPLOYDYNAMIC) {
                        def bitbucketBranchNameTemp = scm.branches[0].name
                        BITBUCKET_BRANCH_NAME = "${bitbucketBranchNameTemp.split('/').size() > 1 ? bitbucketBranchNameTemp.split('/')[1..-1].join('/') : bitbucketBranchNameTemp}"
                        
                        // Load General Config Settings
                        configFileProvider([configFile(fileId: "${JENKINS_GENERALCONFIG_ID}", variable: 'configfile')]) {
                            def generalProps = readProperties file: "$configfile"
                            NOTIFICATION_EMAIL_FAILED_SUBJECT = generalProps['NOTIFICATION_EMAIL_FAILED_SUBJECT'].replace("{JOB_NAME}","${env.JOB_NAME}").replace("{BUILD_NUMBER}","${env.BUILD_NUMBER}")
                            NOTIFICATION_EMAIL_FAILED_BODY = generalProps['NOTIFICATION_EMAIL_FAILED_BODY'].replace("{JOB_NAME}","${env.JOB_NAME}").replace("{BUILD_NUMBER}","${env.BUILD_NUMBER}").replace("{BUILD_URL}","${env.BUILD_URL}")
                            NOTIFICATION_TEAMS_SUCCESS_STATUS = generalProps['NOTIFICATION_TEAMS_SUCCESS_STATUS']
                            NOTIFICATION_TEAMS_SUCCESS_MESSAGE = generalProps['NOTIFICATION_TEAMS_SUCCESS_MESSAGE'].replace("{BUILD_NUMBER}","${env.BUILD_NUMBER}")
                            NOTIFICATION_TEAMS_SUCCESS_COLOR = generalProps['NOTIFICATION_TEAMS_SUCCESS_COLOR']
                            NOTIFICATION_TEAMS_FAILED_STATUS = generalProps['NOTIFICATION_TEAMS_FAILED_STATUS'].replace("{BUILD_URL}","${env.BUILD_URL}")
                            NOTIFICATION_TEAMS_FAILED_MESSAGE = generalProps['NOTIFICATION_TEAMS_FAILED_MESSAGE'].replace("{BUILD_NUMBER}","${env.BUILD_NUMBER}")
                            NOTIFICATION_TEAMS_FAILED_COLOR = generalProps['NOTIFICATION_TEAMS_FAILED_COLOR']
                        }
                        
                        // Load Client Config Settings
                        configFileProvider([configFile(fileId: "${JENKINS_CLIENTCONFIG_ID}", variable: 'configfile')]) {
                            def clientProps = readProperties file: "$configfile"
                            DXP_PROJECT_ID = clientProps['dxp_project_id']
                            INTE_DXP_API_KEY = clientProps['inte_dxp_api_key']
                            INTE_DXP_API_SECRET = clientProps['inte_dxp_api_secret']
                            PREPROD_DXP_API_KEY = clientProps['preprod_dxp_api_key']
                            PREPROD_DXP_API_SECRET = clientProps['preprod_dxp_api_secret']
                            PROD_DXP_API_KEY = clientProps['prod_dxp_api_key']
                            PROD_DXP_API_SECRET = clientProps['prod_dxp_api_secret']
                            TEAMS_WEBHOOK_URLS = clientProps['teams_webhooks']
                        }
                        
                        if (JENKINS_TARGET_ENVIRONMENT == INTE_TARGET_NAME) {
                            DXP_API_KEY = INTE_DXP_API_KEY
                            DXP_API_SECRET = INTE_DXP_API_SECRET
                            JIRA_TARGET_ENV_TYPE = INTE_JIRA_TARGET_ENV_TYPE
                            JIRA_DEPLOY_STATUS = INTE_JIRA_DEPLOY_STATUS
                            ARCHIVE_ARTIFACTS = INTE_ARCHIVE_ARTIFACTS
                            TEAMS_ALLOW_NOTIFICATIONS = INTE_TEAMS_ALLOW_NOTIFICATIONS
                            YARN_COMMAND = INTE_YARN_COMMAND
                            logging.WriteMessage()
                            logging.WriteMessage("This job is running using the ${JENKINS_TARGET_ENVIRONMENT} configuration.")
                        }
                        else if (JENKINS_TARGET_ENVIRONMENT == PREPROD_TARGET_NAME) {
                            DXP_API_KEY = PREPROD_DXP_API_KEY
                            DXP_API_SECRET = PREPROD_DXP_API_SECRET
                            JIRA_TARGET_ENV_TYPE = PREPROD_JIRA_TARGET_ENV_TYPE
                            JIRA_DEPLOY_STATUS = PREPROD_JIRA_DEPLOY_STATUS
                            ARCHIVE_ARTIFACTS = PREPROD_ARCHIVE_ARTIFACTS
                            TEAMS_ALLOW_NOTIFICATIONS = PREPROD_TEAMS_ALLOW_NOTIFICATIONS
                            YARN_COMMAND = PREPROD_YARN_COMMAND
                            logging.WriteMessage()
                            logging.WriteMessage("This job is running using the ${JENKINS_TARGET_ENVIRONMENT} configuration.")
                        } 
                        else if (JENKINS_TARGET_ENVIRONMENT == PROD_TARGET_NAME) {
                            DXP_API_KEY = PROD_DXP_API_KEY
                            DXP_API_SECRET = PROD_DXP_API_SECRET
                            JIRA_TARGET_ENV_TYPE = PROD_JIRA_TARGET_ENV_TYPE
                            JIRA_DEPLOY_STATUS = PROD_JIRA_DEPLOY_STATUS
                            ARCHIVE_ARTIFACTS = PROD_ARCHIVE_ARTIFACTS
                            TEAMS_ALLOW_NOTIFICATIONS = PROD_TEAMS_ALLOW_NOTIFICATIONS
                            YARN_COMMAND = PROD_YARN_COMMAND
                            logging.WriteMessage()
                            logging.WriteMessage("This job is running using the ${JENKINS_TARGET_ENVIRONMENT} configuration.")
                        }
                        else {
                            error("Either the target environment '${JENKINS_TARGET_ENVIRONMENT}' or branch '${BITBUCKET_BRANCH_NAME}' are not supported.")
                        }
                        
                        if (JENKINS_EXECUTION_TYPE != EXECUTION_TYPE_BUILDTEST && JENKINS_EXECUTION_TYPE != EXECUTION_TYPE_DEPLOYDYNAMIC) {
                            logging.WriteSectionMessage("Loading JIRA Data")
                            
                            def commitMessageTemp = bat (script: "git log --format=format:%%s -1", returnStdout: true).trim()
                            BITBUCKET_COMMIT_MESSAGE = commitMessageTemp.replace("\"", "")
                            
                            withCredentials([[$class: 'UsernamePasswordMultiBinding', credentialsId: JIRA_CREDS_ID, usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD']]) {
                                JIRA_USERNAME = env.USERNAME
                                JIRA_ACCESSTOKEN = env.PASSWORD
                            }
                            
                            JIRA_POWERSHELL_COMMAND_FORMAT = "${JENKINS_JIRAUPDATE_PATH} -jenkinsProjectType \"${JENKINS_EXECUTION_TYPE}\" -InquiryType \"{InquiryType}\" -targetEnv \"${JENKINS_TARGET_ENVIRONMENT}\" -bitbucketBranchName \"${BITBUCKET_BRANCH_NAME}\" -bitbucketCommitMessage \"${BITBUCKET_COMMIT_MESSAGE}\" -jiraUserName \"${JIRA_USERNAME}\" -jiraApiToken \"${JIRA_ACCESSTOKEN}\" -jiraProjectIDs \"${JIRA_PROJECT_IDS}\" -jiraDeployStatusOverride \"${JIRA_DEPLOY_STATUS}\" -jiraFixVersionPrefix \"${JIRA_FIXVERSION_PREFIX}\" -verboseLogging \"${USE_VERBOSE_LOGGING}\" -testMode \"${USE_TEST_MODE}\""
                        }
                    }
                    else {
                        error("The execution type '${JENKINS_EXECUTION_TYPE}' is not supported.")
                    }
                }
            }
        }
        stage('Update JIRA Tickets (PRE)') {
            when {
                allOf {
                    expression{JIRA_POWERSHELL_COMMAND_FORMAT != ''}
                    expression{JENKINS_EXECUTION_TYPE != EXECUTION_TYPE_BUILDTEST}
                    expression{JENKINS_EXECUTION_TYPE != EXECUTION_TYPE_DEPLOYDYNAMIC}
                }
            }
            steps {
                script {
                    JIRA_TICKET_IDS = jira.UpdateTicketsPreJobExecution(command: JIRA_POWERSHELL_COMMAND_FORMAT.replace("{InquiryType}", "PreExecution"))
                }
            }
        }
        stage('Build') {
            steps {
            
                script {
                    jenkins.CleanupWorkspace()
                    checkout scm
                    
                    logging.WriteSectionMessage("Restoring NuGet Packages")
                    bat "nuget.exe restore \"${env.WORKSPACE}\\Certinia.sln\" -ConfigFile ${JENKINS_NUGET_PATH}"
                    
                    logging.WriteSectionMessage("Building Frontend Solution")
                    
                    logging.WriteSubsectionMessage("Installing Yarn")
                    dir("${env.WORKSPACE}\\source\\Certinia.Web\\ClientApp"){
                        bat "npm install --global yarn@1.22.22"
                    }
                    
                    logging.WriteSubsectionMessage("Loading Yarn")
                    dir("${env.WORKSPACE}\\source\\Certinia.Web\\ClientApp"){
                        bat "yarn"
                    }
                    
                    logging.WriteSubsectionMessage("Running Yarn")
                    dir("${env.WORKSPACE}\\source\\Certinia.Web\\ClientApp"){
                        bat "yarn run ${YARN_COMMAND}"
                    }
                    
                    logging.WriteSectionMessage("Building Backend Solution")
                    bat "dotnet publish \"${env.WORKSPACE}\\source\\Certinia.Web\\Certinia.Web.csproj\" --configuration Release"
                    
                    logging.WriteSectionMessage("Preparing Build Output For DXP")
                    powershell script: "${JENKINS_DXPBUILD_PATH} -deployPackagePreface \"${JENKINS_TARGET_ENVIRONMENT}\" -siteTypes \"Cms\" -jenkinsWorkSpace \"${env.WORKSPACE}\\source\" -jenkinsBuildNumber \"${env.BUILD_NUMBER}\" -customPackagePath \"Certinia.Web\\bin\\Release\\net9.0\\publish\\*\" -jenkinsExecutionType \"${JENKINS_EXECUTION_TYPE}\""
                }
            }
        }
        stage('Deploy') {
            when {
                anyOf {
                    expression{JENKINS_EXECUTION_TYPE == EXECUTION_TYPE_DEPLOY}
                    expression{JENKINS_EXECUTION_TYPE == EXECUTION_TYPE_DEPLOYDYNAMIC}
                }
            }
            steps {
                script {
                    if(DXP_PROJECT_ID != "" && DXP_API_KEY != "" && DXP_API_SECRET != "")
                    {
                        if(JIRA_TICKET_IDS != '')
                        {
                           logging.WriteSectionMessage("Updating JIRA Ticket(s) As Deployment In Process")
                           def jiraDeploytResponse = jiraSendDeploymentInfo environmentId: "${JENKINS_TARGET_ENVIRONMENT}", environmentName: "${JENKINS_TARGET_ENVIRONMENT}", environmentType: "${JIRA_TARGET_ENV_TYPE}", state: 'in_progress', issueKeys: JIRA_TICKET_IDS
                        }
                        
                        logging.WriteSectionMessage("Deploying To The DXP")
                        powershell script: "${JENKINS_DXPDEPLOY_PATH} -apiKey \"${DXP_API_KEY}\" -apiSecret \"${DXP_API_SECRET}\" -projectId \"${DXP_PROJECT_ID}\" -teamsWebhook \"${TEAMS_WEBHOOK_URLS}\" -jenkinsJobName \"${env.JOB_NAME}\" -jenkinsJobNumber \"${env.BUILD_NUMBER}\" -jenkinsDeploymentPackagePath \"${env.WORKSPACE}\\source\" -targetEnvironment \"${JENKINS_TARGET_ENVIRONMENT}\" -useMaintenancePage \"${DXP_SHOW_MAINTENANCE_PAGE}\" -useDirectDeploy \"${DXP_USE_DIRECT_DEPLOY}\" -smoothDeployMode \"${DXP_SMOOTH_DEPLOY_MODE}\" -verboseLogging \"${USE_VERBOSE_LOGGING}\" -testMode \"${USE_TEST_MODE}\""
                    }
                    else
                    {
                        if(DXP_PROJECT_ID == "") { error("The DXP project ID was missing.") }
                        if(DXP_API_KEY == "") { error("The DXP API key was missing.") }
                        if(DXP_API_SECRET == "") { error("The DXP API secret was missing.") }
                    }
                }
            }
        }
        stage('Update JIRA Tickets (POST)') {
            when {
                allOf {
                    expression{JIRA_POWERSHELL_COMMAND_FORMAT != ''}
                    expression{JENKINS_EXECUTION_TYPE != EXECUTION_TYPE_BUILDTEST}
                    expression{JENKINS_EXECUTION_TYPE != EXECUTION_TYPE_DEPLOYDYNAMIC}
                }
            }
            steps {
                    script {
                        jira.UpdateTicketsPostJobExecution(command: JIRA_POWERSHELL_COMMAND_FORMAT.replace("{InquiryType}", "PostExecution"), jenkinsExecutionType: JENKINS_EXECUTION_TYPE, executionTypeBuild: EXECUTION_TYPE_BUILD, jenkinsTargetEnv: JENKINS_TARGET_ENVIRONMENT, prodTargetName: PROD_TARGET_NAME)
                }
            }
        }
    }
    post {
        success {
            script {
                if(JENKINS_EXECUTION_TYPE == EXECUTION_TYPE_DEPLOY && JIRA_TICKET_IDS != '')
                {
                    jira.UpdateTicketsDeploymentState(environmentId: "${JENKINS_TARGET_ENVIRONMENT}", environmentName: "${JENKINS_TARGET_ENVIRONMENT}", environmentType: "${JIRA_TARGET_ENV_TYPE}", state: 'successful', ticketIDs: JIRA_TICKET_IDS)
                }
                
                if(ARCHIVE_ARTIFACTS == 'true')
                {
                    jenkins.ArchiveArtifacts("**/source/*.nupkg")
                }
                
                if(JENKINS_EXECUTION_TYPE == EXECUTION_TYPE_BUILD)
                {
                    notifications.SendTeamsMessage(webhookList: TEAMS_WEBHOOK_URLS, message: NOTIFICATION_TEAMS_SUCCESS_MESSAGE, status: NOTIFICATION_TEAMS_SUCCESS_STATUS, notificationsEnabled: TEAMS_ALLOW_NOTIFICATIONS)
                }
                
                jenkins.CleanupWorkspace(isPostBuild: true)
                logging.WriteTestModeMessage(USE_TEST_MODE == 'true')
            }
         }
        failure {
            script {
                if(JENKINS_EXECUTION_TYPE == EXECUTION_TYPE_DEPLOY && JIRA_TICKET_IDS != '')
                {
                    jira.UpdateTicketsDeploymentState(environmentId: "${JENKINS_TARGET_ENVIRONMENT}", environmentName: "${JENKINS_TARGET_ENVIRONMENT}", environmentType: "${JIRA_TARGET_ENV_TYPE}", state: 'failed', ticketIDs: JIRA_TICKET_IDS)
                }
                
                if(JENKINS_EXECUTION_TYPE != EXECUTION_TYPE_BUILDTEST)
                {
                    notifications.SendTeamsMessage(webhookList: TEAMS_WEBHOOK_URLS, message: NOTIFICATION_TEAMS_FAILED_MESSAGE, status: NOTIFICATION_TEAMS_FAILED_STATUS, notificationsEnabled: TEAMS_ALLOW_NOTIFICATIONS)
                    notifications.SendEmail(to: ERROR_EMAIL_RECIPIENTS, subject: NOTIFICATION_EMAIL_FAILED_SUBJECT, body: NOTIFICATION_EMAIL_FAILED_BODY)
                }
                else
                {
                    notifications.SendEmail(to: ERROR_BUILDTEST_EMAIL_RECIPIENTS, subject: NOTIFICATION_EMAIL_FAILED_SUBJECT, body: NOTIFICATION_EMAIL_FAILED_BODY)
                }
                
                logging.WriteTestModeMessage(USE_TEST_MODE == 'true')
            }
        }
    }
}