//Jenkins file for nvmt docker image
def branchName = 'UNKNOWN'
def command = 'UNKNOWN'
def image_name = "128144341703.dkr.ecr.us-west-1.amazonaws.com/nvmt"
def image_repo_name = 'nvmt'

pipeline {
    //agent any
    agent {label 'ec2-build-agent'}
    environment {
        SLACK_CHANNELS = "#polaris_deployments"
        REPOSITORY_URL = "https://128144341703.dkr.ecr.us-west-1.amazonaws.com"
        ECR_MACHINE_USER_CREDENTIAL_ID = 'ecr-machine-user'
    }
    options {
        timeout(time: 15, unit: 'MINUTES')
        disableConcurrentBuilds()
    }
    stages {

        stage('Compile') {
            steps {
                echo 'Before Compile ' + env.GIT_BRANCH
                sh "npm install"
                echo 'After Compile ' + env.GIT_BRANCH
            }
        }
        stage('Check Style') {
            steps {
                echo 'Before Checkstyle ' + env.GIT_BRANCH
                sh "npm run checkstyle"
                echo 'After Checkstyle ' + env.GIT_BRANCH
            }
        }
        stage('Check Type') {
            steps {
                echo 'Before Checktype ' + env.GIT_BRANCH
                sh "npm run checktype"
                echo 'After Checktype ' + env.GIT_BRANCH
            }
        }
        stage('Build') {
            steps {
                sh "npm run build"
                echo 'Adding manifest.json file to build folder'
                sh "cp manifest.json nvmt/"
            }
        }
        stage('Test') {
            steps {
                script {
                    try {
                        sh "npm run testReport"
                    } finally {
                        publishHTML(target: [
                            allowMissing: true,
                            alwaysLinkToLastBuild: true,
                            keepAll: true,
                            reportDir: 'coverage',
                            reportFiles: 'index.html',
                            reportName: 'Test Results',
                            reportTitles: ''
                        ])
                    }
                }

            }
        }
        stage('Zip Artifact') {
            steps {
                sh "zip -r nvmt.zip nvmt"
                sh "zip -u nvmt.zip NVmtAppController.groovy"
                sh "mkdir -p $image_repo_name"
                sh "cp nvmt.zip $image_repo_name/nvmt.zip"
            }
        }
        stage('Black Duck') {
            environment {
                BLACK_DUCK_CREDS = credentials('black_duck-user-password')
                PROJECT_NAME = "${image_repo_name}"
                PROJECT_VERSION= sh(script: "cat package.json | grep version| awk -F: '{print \$2}'| sed 's/[\" ,]//g' | tr -d '\n'", returnStdout: true)
            }
            when {
                anyOf {
                    tag 't*'
                }
            }
            steps {
                script {
                    sh """#!/bin/bash
                        /bin/bash <(curl -s https://detect.synopsys.com/detect.sh) --blackduck.url=\"https://navis.blackducksoftware.com\" --blackduck.api.token=MjkyZGZkMWYtNDBkZS00MzdhLWE1ZjctMGUxZTQwNWM1ZDE5OjhmYjZlNThhLTlhNWUtNDNlYS1iZmIzLThhMTI4NDhhMTUzMg --detect.project.name=\$PROJECT_NAME --detect.project.version.name=\$PROJECT_VERSION --detect.source.path=$image_repo_name
                        """
                }
            }
        }
        stage('Nexus Upload') {
            environment {
                JENKINS_USER_CREDS = credentials('jenkins-ldap-user-password')
                ENV_NAME = "${env.GIT_BRANCH}"
            }
            when {
                anyOf {
                    branch 'develop';
                    tag "*"
                }
            }
            steps {
                echo 'Publishing Branch: ' + ENV_NAME
                script {
                    // extracting package version from package.json
                    TAGGED_PACKAGE_VERSION= sh(script: "cat package.json | grep version| awk -F: '{print \$2}'| sed 's/[\" ,]//g' | tr -d '\n'", returnStdout: true)
                    echo "Tagged Package version ${TAGGED_PACKAGE_VERSION}"
                    final String response = sh(script: "curl -v -u ${JENKINS_USER_CREDS_USR}:${JENKINS_USER_CREDS_PSW}  --upload-file $image_repo_name/nvmt.zip https://nexus.navis-dev.com/repository/maven-navis/com/navis/webui/$image_repo_name/$image_repo_name-${TAGGED_PACKAGE_VERSION}.zip", returnStdout: true)
                }
            }
        }
        stage('Generate API doc') {
            steps {
                sh "npm run docs"
            }
        }
        stage('Build Docker Image') {
	        when {
                anyOf {
                    branch 'develop'
                }
            }
            steps {
                echo 'Branchname from git ...' + env.GIT_BRANCH
                script {
                    if (env.GIT_BRANCH.contains('origin/')) {
                        branchName = env.GIT_BRANCH.replaceAll("origin/", "")
                        branchName = env.GIT_BRANCH.replace("/", "_")
                    } else {
				        branchName = env.GIT_BRANCH.toLowerCase()
				    }
                }
                echo "Pulling... ${branchName}"
                sh "docker build -t ${image_repo_name}:${branchName} ."
            }
        }
        stage('Image Upload to ECR') {
	        when {
                branch 'develop'
            }
            steps {
                echo "Uploading ${image_repo_name}"
                withCredentials([[
                  $class: 'AmazonWebServicesCredentialsBinding',
                  credentialsId: "$ECR_MACHINE_USER_CREDENTIAL_ID"]]) {
                      sh "env"
                      /* sh "\$(aws ecr get-login --no-include-email --region us-west-1)" */
                      sh "aws ecr get-login --region us-west-1 | awk '{print \$6}' | docker login -u AWS --password-stdin $REPOSITORY_URL"
                      sh "docker tag ${image_repo_name}:${branchName} ${image_name}:${branchName}"
                      sh "docker push ${image_name}:${branchName}"
                }
            }
        }
        //stage('K8s Deployment') {
            //when {
                //branch 'develop'
            //}
            //steps {
                //echo "Deploying ${image_repo_name} into K8 ... start"
                //withCredentials([kubeconfigContent(credentialsId: 'yued-centos-k8-config-dev', variable: 'KUBECONFIG_CONTENT')]) {
                    //sh '''echo "$KUBECONFIG_CONTENT" > nvmt_kubeconfig && cat nvmt_kubeconfig '''
                //}
                //script {
                    //if (image_name.contains('/')){
                        //image_name = image_name.replace("/", "\\/")
                    //}
                //}
                //echo "Image and tag token replacement"
                //sh "sed -i -e 's/IMAGE_NAME_TOKEN/${image_name}/g' infra/dev/deployment.yaml"
                //sh "sed -i -e 's/IMAGE_TAG_TOKEN/${branchName}/g' infra/dev/deployment.yaml"
                //echo "Deleting existing pod ... start"
                //sh "set +e \n" + "kubectl delete -f infra/dev/deployment.yaml --kubeconfig=nvmt_kubeconfig \n" + " set -e \n"
                //sh "set +e \n" + "kubectl delete -f infra/dev/service.yaml --kubeconfig=nvmt_kubeconfig \n" + " set -e \n"
                //echo "Deleting existing pod ... end"
                //echo "Deploying new pod ... start"
                //sh "kubectl apply -f infra/dev/deployment.yaml --kubeconfig=nvmt_kubeconfig "
                //sh "kubectl apply -f infra/dev/service.yaml --kubeconfig=nvmt_kubeconfig "
                //echo "Deploying new pod ... end"
                //echo "Removing  nvmt_kubeconfig "
                //sh "rm    nvmt_kubeconfig"
                //echo "Deploying ${image_repo_name} into K8 ... end"
            //}
        //}
    }
    post {
        success {
          slackSend (
            // use default channel for this jenkins master,
            // which should be a firehose channel
            color: "#00FF00",
            message: "OK *${env.JOB_NAME}* *${env.BRANCH_NAME}* (${env.BUILD_URL}console)"
          )
        }
        failure {
          slackSend (
            channel: "${env.SLACK_CHANNELS}",
            color: "#FF0000",
            message: "*${env.JOB_NAME}* *${env.BRANCH_NAME}* (${env.BUILD_URL}console) job failed"
          )
        }
        unstable {
          slackSend(
            channel: "${env.SLACK_CHANNELS}",
            color: "#00FFFF",
            message: "*${env.JOB_NAME}* *${env.BRANCH_NAME}* (${env.BUILD_URL}console) job is unstable."
          )
        }
        fixed {
          slackSend (
            // use default channel for this jenkins master,
            // which should be a firehose channel
            channel: "${env.SLACK_CHANNELS}",
            color: "#00FF00",
            message: "OK (FIXED!) *${env.JOB_NAME}* *${env.BRANCH_NAME}* (${env.BUILD_URL}console)"
          )
        }
    }
}