def checkBranchConditions(parameter="default") {
  switch(parameter) {
    case "default":
      switch(env.BRANCH_NAME) {
        case "master":
        case ~/release.*$/:
        case ~/^dev(elop)*$/:
          return true
        default:
          return false
      }
    case "yes":
      return true
    case "no":
      return false
    default:
      return false
  }
}

def checkPRConditions(parameter="default") {
  switch(parameter) {
    case "default":
      switch(env.BRANCH_NAME) {
        case ~/PR-.*$/:
          return true
        default:
          return false
      }
    case "yes":
      return true
    case "no":
      return false
    default:
      return false
  }
}

def setPythonDepsPipelineVars(projectPath) {
  // uses common environment variables to set parameter map for pythonPackagePipeline method
  def params = [:]
  // Common variables to parameters
  params.awsProfile              = env.AWS_PROFILE
  //ProjectSpecific parameters
  params.workDir                 = "${env.WORKSPACE}/${projectPath}"
  return params
}

def setPythonPipelineVars(projectPath, pythonPackageUploadMode ) {
  // uses common environment variables to set parameter map for pythonPackagePipeline method
  def params = [:]
  // Common variables to parameters
  params.awsProfile              = env.AWS_PROFILE
  params.pythonPackageUploadMode = pythonPackageUploadMode
  //ProjectSpecific parameters
  params.projectName             = projectPath.split('/')[-1]
  params.workDir                 = "${env.WORKSPACE}/${projectPath}"

  return params
}

def pythonDepsPipeline(params) {
  withEnv(["AWS_PROFILE=${params.awsProfile}"]) {
    stage("Build Python dependencies") {
      echo sh(script: "cd ${params.workDir} && make docker/clean", returnStdout: true).trim()
      echo sh(script: "cd ${params.workDir} && make docker/deps", returnStdout: true).trim()
    }
  }
}

def setPythonTestPipelineVars(projectPath, projectName) {
  // uses common environment variables to set parameter map for pythonPackagePipeline method
  def params = [:]
  // Common variables to parameters
  params.awsProfile              = env.AWS_PROFILE
  //ProjectSpecific parameters
  if (projectName == '') {
    params.projectName = projectPath.split('/')[-1]
  } else {
    params.projectName = projectName
  }
  params.workDir                 = "${env.WORKSPACE}/${projectPath}"

  return params
}

def pythonLinterPipeline(params) {
  logJenkinsParams(params)
  withEnv(["AWS_PROFILE=${params.awsProfile}"]) {
    stage("Run lint and typecheck") {
      echo "Linter is enabled."
      echo sh(script: "cd ${params.workDir} && make docker/fmtcheck", returnStdout: true).trim()
      echo sh(script: "cd ${params.workDir} && make docker/lint", returnStdout: true).trim()
      echo sh(script: "cd ${params.workDir} && make docker/typecheck", returnStdout: true).trim()
    }
  }
}

def pythonTestPipeline(params) {
  try {
    logJenkinsParams(params)
    withEnv(["AWS_PROFILE=${params.awsProfile}"]) {
      stage("Run tests") {
        echo sh(script: "cd ${params.workDir} && make docker/clean", returnStdout: true).trim()
        echo sh(script: "cd ${params.workDir} && make docker/test", returnStdout: true).trim()
      }
    }
  }
  finally {
    logJenkinsParams(params)
    junit "**/junitreport.xml"
    recordCoverage(
      tools: [[parser: 'COBERTURA', pattern: '**/coverage.xml']],
      enabledForFailure: true,
      failOnError: true,
      sourceDirectories: [[path: "${params.workDir}"]]
    )
  }
}

def pythonIntegrationTestPipeline(params) {
  try {
    logJenkinsParams(params)
    withEnv(["AWS_PROFILE=${params.awsProfile}"]) {
      stage("Run integration tests") {
        echo sh(script: "cd ${params.workDir} && make docker/clean", returnStdout: true).trim()
        echo sh(script: "cd ${params.workDir} && make docker/integration", returnStdout: true).trim()
      }
    }
  }
  finally {
    logJenkinsParams(params)
    junit "**/junitreport.xml"
    recordCoverage(
      tools: [[parser: 'COBERTURA', pattern: '**/coverage.xml']],
      enabledForFailure: true,
      failOnError: true,
      sourceDirectories: [[path: "${params.workDir}"]]
    )
  }
}

def logJenkinsParams(jenkinsParams) {
  for ( param in jenkinsParams ) {
    echo "key = ${param.key}, value = ${param.value}"
  }
}

def pythonPackagePipeline(params) {
  withEnv(["AWS_PROFILE=${params.awsProfile}"]) {
    stage('Build and upload python package') {
      echo "Workdir is ${params.workDir}"
      echo sh(script: "cd ${params.workDir} && make docker/clean", returnStdout: true).trim()
      echo sh(script: "cd ${params.workDir} && make docker/upload", returnStdout: true).trim()
    }
  }
}

def setDockerPipelineParams(imageUploadMode, failIfReleaseExists, projectPath, projectGroup, ecr, ecrRepoSubfolder='', octoProjectName='', projectName='') {
  // uses common environment variables to set parameter map for dockerPipeline method

  def params = [:]
  // Jenkins build parameters
  params.imageUploadMode     = imageUploadMode
  params.failIfReleaseExists = failIfReleaseExists

  // Common variables to parameters
  params.awsProfile     = env.AWS_PROFILE
  params.octopusChannel = env.OCTOPUS_CHANNEL
  params.deployEnv      = env.DEPLOY_ENV

  // Parameters for octopus deploy and ECR
  params.projectName    = projectName ?: projectPath.split('/')[-1]
  params.octopusProject = octoProjectName ?: "${projectGroup}.${params.projectName.replace('_','-')}"
  params.workDir        = "${env.WORKSPACE}/${projectPath}"
  if (ecrRepoSubfolder == '') {
    params.ecrRepository = "${projectGroup}/${params.projectName.replace('_','-')}"
  } else {
    params.ecrRepository = "${projectGroup}/${ecrRepoSubfolder}/${params.projectName.replace('_','-')}"
  }
  params.registry = "${ecr}/${params.ecrRepository}"
  params.version  = octopus.getVersion(env.BRANCH_NAME,params.workDir)

  return params
}

def dockerPipeline(params) {
  stage('check version') {
    if (params.imageUploadMode == 'error' && octopus.ecrImageTagExists(params.version,params.ecrRepository,params.awsProfile)) {
      error "Image with ${params.version} version tag already exists. To ignore this error set IMAGE_UPLOAD_MODE parameter to overwrite or skip_build"
    }
  }
  withEnv(["REGISTRY=${params.registry}", "VERSION=${params.version}", "AWS_PROFILE=${params.awsProfile}"]){
    stage('Build and push to ECR') {
      if (params.imageUploadMode == 'overwrite' || !octopus.ecrImageTagExists(params.version,params.ecrRepository,params.awsProfile)) {
        echo sh(script: "cd ${params.workDir} && make docker/clean", returnStdout: true).trim()
        echo sh(script: "cd ${params.workDir} && make docker/image/build", returnStdout: true).trim()
        echo sh(script: "cd ${params.workDir} && make docker/image/push", returnStdout: true).trim()
        //Publish Build information to Octopus here
        octopus.prismaCloudScanImage(params.version,params.ecrRepository,params.awsProfile)
        octopus.createPackageBuildInformation(params.ecrRepository, params.version)
      } else {
        echo "Step skipped due to conditions."
      }
    }
  }
  stage('Create a release in octopus') {
    if (params.failIfReleaseExists == 'yes' || !octopus.releaseExists(params.octopusProject,params.version)) {
      echo octopus.createRelease(params.octopusProject,params.version,params.octopusChannel)
    } else {
      echo "Step skipped due to conditions."
    }
  }
  stage('Deploy release in octopus') {
    if (params.deployEnv != 'skip_deployment') {
      echo octopus.deployRelease(params.octopusProject,params.deployEnv,params.version,params.octopusChannel)
    } else {
      echo "Step skipped due to conditions."
    }
  }
}

// When pipeline includes both lambda and ECS task
def setDockerMixedPipelineParams(imageUploadMode, failIfReleaseExists, projectPath, projectGroup, ecr, octoProjectName='', projectName='') {
  // uses common environment variables to set parameter map for dockerMixedPipeline method

  def params = [:]
  // Jenkins build parameters
  params.imageUploadMode     = imageUploadMode
  params.failIfReleaseExists = failIfReleaseExists

  // Common variables to parameters
  params.awsProfile     = env.AWS_PROFILE
  params.octopusChannel = env.OCTOPUS_CHANNEL
  params.deployEnv      = env.DEPLOY_ENV

  // Parameters for octopus deploy and ECR
  params.projectName         = projectName ?: projectPath.split('/')[-1]
  params.octopusProject      = octoProjectName ?: "${projectGroup}.${params.projectName.replace('_','-')}"
  params.workDir             = "${env.WORKSPACE}/${projectPath}"
  params.ecrLambdaRepository = "${projectGroup}/lambda/${params.projectName.replace('_','-')}"
  params.ecrTaskRepository   = "${projectGroup}/${params.projectName.replace('_','-')}"
  params.registry            = "${ecr}/${params.ecrLambdaRepository}"
  params.taskRegistry        = "${ecr}/${params.ecrTaskRepository}"
  params.version             = octopus.getVersion(env.BRANCH_NAME,params.workDir)

  return params
}

def dockerMixedPipeline(params) {
  stage('check version') {
    if (params.imageUploadMode == 'error' && octopus.ecrImageTagExists(params.version,params.ecrLambdaRepository,params.awsProfile)) {
      error "Lambda image with ${params.version} version tag already exists. To ignore this error set IMAGE_UPLOAD_MODE parameter to overwrite or skip_build"
    }
    if (params.imageUploadMode == 'error' && octopus.ecrImageTagExists(params.version,params.ecrTaskRepository,params.awsProfile)) {
      error "Task image with ${params.version} version tag already exists. To ignore this error set IMAGE_UPLOAD_MODE parameter to overwrite or skip_build"
    }
  }
  withEnv(["REGISTRY=${params.registry}", "TASK_REGISTRY=${params.taskRegistry}", "VERSION=${params.version}", "AWS_PROFILE=${params.awsProfile}"]){
    stage('Build and push to ECR') {
      // Lambda
      if (params.imageUploadMode == 'overwrite' || !octopus.ecrImageTagExists(params.version,params.ecrLambdaRepository,params.awsProfile)) {
        echo sh(script: "cd ${params.workDir} && make docker/clean", returnStdout: true).trim()
        echo sh(script: "cd ${params.workDir} && make docker/image/build", returnStdout: true).trim()
        echo sh(script: "cd ${params.workDir} && make docker/image/push", returnStdout: true).trim()
        //Publish Build information to Octopus here
        octopus.prismaCloudScanImage(params.version,params.ecrLambdaRepository,params.awsProfile)
        octopus.createPackageBuildInformation(params.ecrLambdaRepository, params.version)
      } else {
        echo "Step skipped due to conditions."
      }
      //Task
      if (params.imageUploadMode == 'overwrite' || !octopus.ecrImageTagExists(params.version,params.ecrTaskRepository,params.awsProfile)) {
        echo sh(script: "cd ${params.workDir} && make docker/clean", returnStdout: true).trim()
        echo sh(script: "cd ${params.workDir} && make docker/task/image/build", returnStdout: true).trim()
        echo sh(script: "cd ${params.workDir} && make docker/task/image/push", returnStdout: true).trim()
        //Publish Build information to Octopus here
        octopus.prismaCloudScanImage(params.version,params.ecrTaskRepository,params.awsProfile)
        octopus.createPackageBuildInformation(params.ecrTaskRepository, params.version)
      } else {
        echo "Step skipped due to conditions."
      }
    }
  }
  stage('Create a release in octopus') {
    if (params.failIfReleaseExists == 'yes' || !octopus.releaseExists(params.octopusProject,params.version)) {
      echo octopus.createRelease(params.octopusProject,params.version,params.octopusChannel)
    } else {
      echo "Step skipped due to conditions."
    }
  }
  stage('Deploy release in octopus') {
    if (params.deployEnv != 'skip_deployment') {
      echo octopus.deployRelease(params.octopusProject,params.deployEnv,params.version,params.octopusChannel)
    } else {
      echo "Step skipped due to conditions."
    }
  }
}

def getPythonPackageStage(jenkinsParams, name, path, type, enforceName=false ) {
  return {
    stage(name) {
      def buildPythonDeps     = checkBranchConditions(jenkinsParams.PYTHON_DEPS_BUILD_UPLOAD_MODE)
      def runTests            = checkBranchConditions(jenkinsParams.RUN_TESTS)
      def buildPythonPackage  = checkBranchConditions(jenkinsParams.BUILD_PYTHON_PACKAGE)
      def triggerDeploy       = checkBranchConditions(jenkinsParams.TRIGGER_DEPLOY)
      def runLinter           = jenkinsParams.RUN_LINTER ? checkPRConditions(jenkinsParams.RUN_LINTER) : false
      def runIntegrationTests = jenkinsParams.RUN_INTEGRATION_TESTS == "yes" ? true : false

      def pipeline_vars = setPythonPipelineVars(path,jenkinsParams.PYTHON_PACKAGE_UPLOAD_MODE)

      if (runLinter) {
        pythonLinterPipeline(pipeline_vars)
      }

      // build python dependencies
      def pypircFilePath
      if (path == '') {
        pypircFilePath = './.pypirc'
      } else {
        pypircFilePath = path + '/.pypirc'
      }
      nexus.generateAuthorizedPypirc(pypircFilePath)

      if (buildPythonDeps) {
        pythonDepsPipeline(
          setPythonDepsPipelineVars(path)
        )
      }

      if (runTests) {
        // run tests
        pythonTestPipeline(pipeline_vars)
        if (runIntegrationTests) {
          // run integration tests
          pythonIntegrationTestPipeline(pipeline_vars)
        }
        // build python package

        if (buildPythonPackage) {
          pythonPackagePipeline(pipeline_vars)
        }
        else {
          echo "Building python package has been skipped."
        }
        // Build image and trigger deploy
        if (triggerDeploy) {
          //nexus.generateCleanPypirc(path + '/.pypirc')
          def dockerPipelineParams
          switch(type) {
            // build docker image with zipped lambda
            case "lambda":
              if (enforceName) {
                dockerPipelineParams = setDockerPipelineParams(
                  jenkinsParams.IMAGE_UPLOAD_MODE,
                  jenkinsParams.FAIL_IF_RELEASE_EXISTS,
                  path, env.PROJECT_GROUP, env.ECR, "lambda", '', name)
              }
              else {
                dockerPipelineParams = setDockerPipelineParams(
                  jenkinsParams.IMAGE_UPLOAD_MODE,
                  jenkinsParams.FAIL_IF_RELEASE_EXISTS,
                  path, env.PROJECT_GROUP, env.ECR, "lambda")
              }
              dockerPipeline(dockerPipelineParams)
              break
            // build docker image with installed python application
            case "task":
              if (enforceName) {
                dockerPipelineParams = setDockerPipelineParams(
                  jenkinsParams.IMAGE_UPLOAD_MODE,
                  jenkinsParams.FAIL_IF_RELEASE_EXISTS,
                  path, env.PROJECT_GROUP, env.ECR, '', '', name)
              }
              else {
                dockerPipelineParams = setDockerPipelineParams(
                  jenkinsParams.IMAGE_UPLOAD_MODE,
                  jenkinsParams.FAIL_IF_RELEASE_EXISTS,
                  path, env.PROJECT_GROUP, env.ECR)
              }
              dockerPipeline(dockerPipelineParams)
              break
            case "mixed":
              if (enforceName) {
                dockerMixedPipelineParams = setDockerMixedPipelineParams(
                  jenkinsParams.IMAGE_UPLOAD_MODE,
                  jenkinsParams.FAIL_IF_RELEASE_EXISTS,
                  path, env.PROJECT_GROUP, env.ECR, '', name)
              }
              else {
                dockerMixedPipelineParams = setDockerMixedPipelineParams(
                  jenkinsParams.IMAGE_UPLOAD_MODE,
                  jenkinsParams.FAIL_IF_RELEASE_EXISTS,
                  path, env.PROJECT_GROUP, env.ECR)
              }
              dockerMixedPipeline(dockerMixedPipelineParams)
              break
            default:
              echo "Target type is not task, lambda, or mixed. Deployment has been skipped."
          }
        }
        else {
          echo "Triggering deployment has been skipped."
        }
      } else {
        echo "Tests and all subsequent steps (building package, triggering deployment) have been skipped."
      }
    }
  }
}

def getChangesLastOrPR() {
  // The function will provide of changelist for last commit,
  // or for whole PR if variable env.CHANGE_TARGET is presented
  def changeset = []
  if (env.CHANGE_TARGET) {
    // PR build
    // https://i.stack.imgur.com/4wMJI.png checkout to get difference between diff with .. and ...
    // Check PR-NN-head or PR-NN-merge
    switch(env.BRANCH_NAME) {
        case ~/PR-(\d+)-merge$/:
            PR_NUM=(env.BRANCH_NAME =~ /\d+/).findAll()[0]
            // echo "DEBUG: getChangesLastOrPR PR_NUM=${PR_NUM}"
            branchout_commit_id = sh(
              script: "git merge-base origin/${env.CHANGE_TARGET} origin/pr/${PR_NUM}",
              returnStdout: true)\
              .trim().toString()
            // echo "DEBUG: getChangesLastOrPR branchout_commit_id=${branchout_commit_id}"
            changeset = sh(
              script: "git --no-pager diff  --name-only ${branchout_commit_id}..origin/${env.BRANCH_NAME}",
              returnStdout: true)\
              .trim().split('\n').collect{it as String}
            break
        default:
            changeset = sh(
              script: "git --no-pager diff  --name-only origin/${env.CHANGE_TARGET}...origin/${env.BRANCH_NAME}",
              returnStdout: true)\
              .trim().split('\n').collect{it as String}
    }
    //echo "DEBUG: getChangesLastOrPR changeset= ${changeset}"
  }
  else {
    changeset = sh(
      script: "git --no-pager diff --name-only HEAD~1",
      returnStdout: true)\
      .trim().split('\n').collect{it as String}
  }
  // Get union of latest commit and PR changes
  return changeset
}

boolean isPathInChangeSet(path) {
  //def changeLogSets = getChangesLastOrPR()
  def changedFilesPathList = []
  def isChanged = false
  changedFilesPathList= getChangesLastOrPR()
  println changedFilesPathList
  changedFilesPathList.each {
    if (it.contains(path)) { isChanged = true }
  }
  return isChanged
}

def defineBuildElements(listOfAllProjects, projectChoice, customListOfProjects) {
  def resultBuildElementsList = []
  switch(projectChoice) {
    case "Build all":
      resultBuildElementsList = listOfAllProjects
      break
    case "Build latest changes":
      listOfAllProjects.each {
        if (isPathInChangeSet("${it.split('/')[-1]}/")) { resultBuildElementsList.add(it) }
      }
      break
    case "Select manually":
      //implement
      resultBuildElementsList = customListOfProjects
    default:
      break
  }
  return resultBuildElementsList
}

//Prepare build stages for a global build stage based on the all stage jobs and userdefined build job list
def preparePythonPackageBuildStages(jenkinsParams, stageJobList, buildJobList, branchId) {
  def stagesMap = [:]
  stageJobList.each{
    stagesMap.put(it, getPythonPackageRunJobStage(jenkinsParams, it, buildJobList, branchId))
  }
  return stagesMap
}

// If job is in the build job list - run corresponding job in jenkins with default parameters
// If not and TEST_ALL or PYTHON_DEPS_BUILD_UPLOAD_MODE is enabled - disable deployment and building Python package
// But install python dependencies and/or run tests
def getPythonPackageRunJobStage(jenkinsParams, job, buildJobList, branchId) {
  return {
    stage(job) {
      def runTests        = checkBranchConditions(jenkinsParams.TEST_ALL)
      def buildPythonDeps = checkBranchConditions(jenkinsParams.PYTHON_DEPS_BUILD_UPLOAD_MODE)

      if (buildJobList.contains(job)) {
        build job: "${job}/${branchId}",
          parameters: [
            string(name: 'PYTHON_DEPS_BUILD_UPLOAD_MODE', value: "${jenkinsParams.PYTHON_DEPS_BUILD_UPLOAD_MODE}"),
            string(name: 'RUN_TESTS', value: "yes"),
            string(name: 'RUN_LINTER', value: "${jenkinsParams.RUN_LINTER}"),
            string(name: 'RUN_INTEGRATION_TESTS', value: "${jenkinsParams.RUN_INTEGRATION_TESTS}"),
            string(name: 'BUILD_PYTHON_PACKAGE', value: "${jenkinsParams.BUILD_PYTHON_PACKAGE}"),
            string(name: 'TRIGGER_DEPLOY', value: "${jenkinsParams.TRIGGER_DEPLOY}"),
            string(name: 'DEPLOY_ENV_CHOICE', value: "${jenkinsParams.DEPLOY_ENV_CHOICE}"),
            string(name: 'IMAGE_UPLOAD_MODE', value: "${jenkinsParams.IMAGE_UPLOAD_MODE}"),
            string(name: 'PYTHON_PACKAGE_UPLOAD_MODE', value: "${jenkinsParams.PYTHON_PACKAGE_UPLOAD_MODE}"),
            string(name: 'FAIL_IF_RELEASE_EXISTS', value: "${jenkinsParams.FAIL_IF_RELEASE_EXISTS}")
          ]
      }
      else if (runTests || buildPythonDeps) {
        //Standard pipeline job doesn't have 'default' value for RUN_TESTS parameter, only 'yes' or 'no'
        //Define it explicitly before proceeding
        runTestsValue = runTests ? "yes" : "no"
        build job: "${job}/${branchId}",
          parameters: [
            string(name: 'PYTHON_DEPS_BUILD_UPLOAD_MODE', value: "${jenkinsParams.PYTHON_DEPS_BUILD_UPLOAD_MODE}"),
            string(name: 'RUN_TESTS', value: "${runTestsValue}"),
            string(name: 'BUILD_PYTHON_PACKAGE', value: "no"),
            string(name: 'TRIGGER_DEPLOY', value: "no")
          ]
      }
      else {
        println "Skipping stage ${job}"
      }
    }
  }
}

// Invokes more generic version of getPythonPackageRunJobStage (V2)
def preparePythonPackageBuildStages_v2(jenkinsParams, stageJobList, buildJobList, branchId) {
  def stagesMap = [:]
  stageJobList.each{
    stagesMap.put(it, getPythonPackageRunJobStage_v2(jenkinsParams, it, buildJobList, branchId))
  }
  return stagesMap
}

// More generic version of getPythonPackageRunJobStage
// Only passes essential parameters during the build
// Doesn't trigger rebuilding of python dependencies or test for all components in the repository
def getPythonPackageRunJobStage_v2(jenkinsParams, job, buildJobList, branchId) {
  return {
    stage(job) {
      if (buildJobList.contains(job)) {
        build job: "${job}/${branchId}",
          parameters: [
            string(name: 'TRIGGER_DEPLOY', value: "${jenkinsParams.TRIGGER_DEPLOY}"),
            string(name: 'DEPLOY_ENV_CHOICE', value: "${jenkinsParams.DEPLOY_ENV_CHOICE}"),
            string(name: 'FAIL_IF_RELEASE_EXISTS', value: "${jenkinsParams.FAIL_IF_RELEASE_EXISTS}")
          ]
      }
      else {
        println "Skipping stage ${job}"
      }
    }
  }
}

def getPythonWebappStage(jenkinsParams, name, path ) {
  return {
    stage(name) {
      def runTests            = checkBranchConditions(jenkinsParams.RUN_TESTS)
      def runIntegrationTests = checkBranchConditions(jenkinsParams.RUN_INTEGRATION_TESTS)
      def triggerDeploy       = checkBranchConditions(jenkinsParams.TRIGGER_DEPLOY)
      def testPassStatus      = false
      def runLinter           = jenkinsParams.RUN_LINTER ? checkBranchConditions(jenkinsParams.RUN_LINTER) : true

      if (runLinter) {
        pythonLinterPipeline(
          setPythonPipelineVars(path,jenkinsParams.PYTHON_PACKAGE_UPLOAD_MODE)
        )
      }

      if (runTests) {
        // run tests
        pythonTestPipeline(
          setPythonPipelineVars(path,jenkinsParams.PYTHON_PACKAGE_UPLOAD_MODE)
        )
        testPassStatus = true
      }
      if (runIntegrationTests) {
        testPassStatus = false
        // run integration tests
        pythonIntegrationTestPipeline(
          setPythonTestPipelineVars(path, name)
        )
        testPassStatus = true
      }
      // Build image and trigger deploy
      if (triggerDeploy && testPassStatus) {
        dockerPipeline(setDockerPipelineParams(
          jenkinsParams.IMAGE_UPLOAD_MODE,
          jenkinsParams.FAIL_IF_RELEASE_EXISTS,
          path, env.PROJECT_GROUP, env.ECR, '', '', name)
        )
      }
      else if (triggerDeploy) {
        echo "Deployment has been skipped due to the tests failure."
      }
      else {
        echo "Triggering deployment has been skipped."
      }
    }
  }
}