Jenkinsfile.e2e

import groovy.json.JsonOutput

def SKIP_RUN = false

pipeline {
    agent {
        node {
            label 'ozgcloud-jenkins-build-agent-jdk21-node20'
        }
    }

    triggers {
        // upstream(upstreamProjects: getUpstreamProjects(), threshold: hudson.model.Result.SUCCESS)
        cron('0 18-23,0-5 * * *')
    }

    environment {
        BLUE_OCEAN_URL = "https://jenkins.infra.ozg-cloud.systems/job/E2E%20Tests/job/${env.BRANCH_NAME}/${env.BUILD_NUMBER}/"
        BUNDESLAND = "by"
        SSO_URL = "sso.dev.by.ozg-cloud.de"
        CLUSTER_BASE_URL = "dev.by.ozg-cloud.de"
        FAILED_STAGE = ""
        FAILED_PARALLEL_STAGE = " "
        EA_BEZEICHNER = generateBezeichner("e2e-ea")
        MAIN_BEZEICHNER = generateBezeichner("e2e-main")
        SH_SUCCESS_STATUS_CODE = 0
    }

    options {
        timeout(time: 2, unit: 'HOURS')
        disableConcurrentBuilds()
        buildDiscarder(logRotator(numToKeepStr: '15'))
        skipDefaultCheckout(true)
    }

    stages {
       stage('Checkout build trigger') {
           when {
               not {
                   anyOf {
                       triggeredBy 'UpstreamCause'
                       triggeredBy 'BuildUpstreamCause'
                       triggeredBy cause: 'UserIdCause'
                       triggeredBy 'TimerTrigger'
                   }
               }
           }
           steps {
               script {
                  SKIP_RUN = true
                   currentBuild.result= "UNSTABLE"
               }
           }
       }
        stage('Check branch') {
            when {
                triggeredBy 'TimerTrigger'
            }
            steps {
                script {
                     if (!isMasterBranch()) {
                        echo "Branchname "+env.BRANCH_NAME+" does not match, skipping e2e tests"
                        SKIP_RUN = true
                    }
                }
            }
        }
        stage('Checkout SCM') {
            when {
                expression { !SKIP_RUN }
            }
            steps {
                script {
                    FAILED_STAGE = env.STAGE_NAME

                    checkout scm
                }
            }
        }
        stage("Clone Gitops Repo") {
            when {
                expression { !SKIP_RUN }
            }
            steps {
                script {
                    FAILED_STAGE = env.STAGE_NAME

                    cloneGitopsRepo()
                }
            }
        }

        stage("Init Default Versions") {
            when {
                expression { !SKIP_RUN }
            }
            steps {
                script {
                    FAILED_STAGE = env.STAGE_NAME

                    initEnvAlfaDefaultVersions()
                    initEnvVorgangManagerDefaultVersions()
                    initEnvUserManagerDefaultVersions()
                }
            }
        }

        stage("Set User Versions") {
            when {
                expression { !SKIP_RUN }
                beforeInput true
                triggeredBy cause: "UserIdCause"
            }
            steps {
                script {
                    FAILED_STAGE = env.STAGE_NAME

                    catchError {
                        timeout(time: 5, unit: 'MINUTES') {
                            userVersions = input message: "Edit Default Values",
                                parameters: [
                                    string(name: "AlfaImageTag", defaultValue: env.ALFA_IMAGE_TAG, trim: true),
                                    string(name: "AlfaHelmChartVersion", defaultValue: env.ALFA_HELM_CHART_VERSION, trim: true),
                                    string(name: "AlfaHelmRepoUrl", defaultValue: env.ALFA_HELM_REPO_URL, trim: true),
                                    string(name: "VorgangManagerImageTag", defaultValue: env.VORGANG_MANAGER_IMAGE_TAG, trim: true),
                                    string(name: "VorgangManagerHelmChartVersion", defaultValue: env.VORGANG_MANAGER_HELM_CHART_VERSION, trim: true),
                                    string(name: "VorgangManagerHelmRepoUrl", defaultValue: env.VORGANG_MANAGER_HELM_REPO_URL, trim: true),
                                    string(name: "UserManagerImageTag", defaultValue: env.USER_MANAGER_IMAGE_TAG, trim: true),
                                    string(name: "UserManagerHelmChartVersion", defaultValue: env.USER_MANAGER_HELM_CHART_VERSION, trim: true),
                                    string(name: "UserManagerHelmRepoUrl", defaultValue: env.USER_MANAGER_HELM_REPO_URL, trim: true)
                                ]

                            initEnvUserVersions(userVersions)
                        }
                    }
                }
            }
        }

        stage('Init k8s') {
            when {
                expression { !SKIP_RUN }
            }
            steps {
                script {
                    FAILED_STAGE = env.STAGE_NAME

                    configFileProvider([configFile(fileId: 'kubeconfig-dev-okd-cluster', variable: 'KUBE_CONFIG')]) {
                        sh 'mkdir ~/.kube'
                        sh 'cp ${KUBE_CONFIG} ~/.kube/config'
                    }

                    sh 'helm version'
                }
            }
        }

        stage('Rollout E2E Namespaces') {
            when {
                expression { !SKIP_RUN }
            }
            steps {
                script {
                    FAILED_STAGE = env.STAGE_NAME

                    checkoutGitopsE2eBranch()

                    deleteOzgCloudStack([env.EA_BEZEICHNER, env.MAIN_BEZEICHNER])

                    generateMainNamespaceYaml()
                    generateEaNamespaceYaml()

                    pushGitopsRepo()
                }
            }
            post {
                failure {
                    script {
                        deleteOzgCloudStack([env.EA_BEZEICHNER, env.MAIN_BEZEICHNER])
                    }
                }
            }
        }

        stage("Install Cypress") {
            when {
                expression { !SKIP_RUN }
            }
            steps {
                script {
                    FAILED_STAGE = env.STAGE_NAME

                    sh 'npm --version'
                    dir('alfa-client') {
                        sh 'echo "registry=https://nexus.ozg-sh.de/repository/npm-proxy" >> ~/.npmrc'
                        sh 'echo "//nexus.ozg-sh.de/:_auth=amVua2luczprTSFnNVUhMVQzNDZxWQ==" >> ~/.npmrc'

                        sh 'npm cache verify'
                        sh 'npm install'
                        sh "npm run cypress:install"
                    }
                }
            }
        }

        stage('Wait for Rollout E2E Namespaces') {
            when {
                expression { !SKIP_RUN }
            }
            steps {
                script {
                    FAILED_STAGE = env.STAGE_NAME

                    waitForOzgCloudStackRollout([env.EA_BEZEICHNER, env.MAIN_BEZEICHNER])
                }
            }
            post {
                failure {
                    script {
                        deleteOzgCloudStack([env.EA_BEZEICHNER, env.MAIN_BEZEICHNER])
                    }
                }
            }
        }

        stage('Init PortForwards') {
            when {
                expression { !SKIP_RUN }
            }
            steps {
                script {
                    FAILED_STAGE = env.STAGE_NAME

                    forwardElasticSearch()
                }
            }
        }

//        stage('Run E2E-Tests') {
//            when {
//                expression { !SKIP_RUN }
//            }
//            failFast false

//            parallel {
                stage('E2E-Alfa-EA') {
                    when {
                        expression { !SKIP_RUN }
                    }
                    steps {
                        catchError(buildResult: 'FAILURE', stageResult: 'FAILURE') {
                            script {
                                def bezeichner = env.EA_BEZEICHNER

                                Integer mongoDbPort = forwardMongoDbPort(generateNamespace(bezeichner))

                                runTests(bezeichner, 'alfa-e2e','einheitlicher-ansprechpartner', mongoDbPort, env.STAGE_NAME)

                                stopForwardMongoDbPort(generateNamespace(bezeichner))
                            }
                        }
                    }
                    post {
                        failure {
                            script {
                                FAILED_PARALLEL_STAGE += "${env.STAGE_NAME} "
                            }
                        }
                        always {
                            script {
                                publishAlfaE2ETestResult("einheitlicher-ansprechpartner", "Alfa E2E-Tests EA")
                            }
                        }
                    }
                }

                stage('E2E-Alfa-Main') {
                    when {
                        expression { !SKIP_RUN }
                    }
                    steps {
                        catchError(buildResult: 'FAILURE', stageResult: 'FAILURE') {
                            script {
                                def bezeichner = env.MAIN_BEZEICHNER

                                Integer mongoDbPort = forwardMongoDbPort(generateNamespace(bezeichner))

                                runTests(bezeichner, 'alfa-e2e','main-tests', mongoDbPort, env.STAGE_NAME)

                                stopForwardMongoDbPort(generateNamespace(bezeichner))
                            }
                        }
                    }
                    post {
                        failure {
                            script {
                                FAILED_PARALLEL_STAGE += "${env.STAGE_NAME} "
                            }
                        }
                        always {
                            script {
                                publishAlfaE2ETestResult("main-tests", "Alfa E2E-Tests main")
                            }
                        }
                    }
                }
                stage('E2E-Admin-Main') {
                  when {
                    expression { !SKIP_RUN }
                  }
                  steps {
                    catchError(buildResult: 'FAILURE', stageResult: 'FAILURE') {
                      script {
                        String bezeichner = env.MAIN_BEZEICHNER

                        Integer mongoDbPort = forwardMongoDbPort(generateNamespace(bezeichner))

                        runTests(bezeichner, 'admin-e2e','main-tests', mongoDbPort, env.STAGE_NAME)

                        stopForwardMongoDbPort(generateNamespace(bezeichner))
                      }
                    }
                  }
                  post {
                    failure {
                      script {
                        FAILED_PARALLEL_STAGE += "${env.STAGE_NAME} "
                      }
                    }
                    always {
                      script {
                        publishAdminE2ETestResult()
                      }
                    }
                  }
                }
//            }
//        }

        stage('Delete E2E Namespaces') {
            when {
                expression { !SKIP_RUN }
            }
            steps {
                script {
                    FAILED_STAGE = env.STAGE_NAME

                    deleteOzgCloudStack([env.EA_BEZEICHNER, env.MAIN_BEZEICHNER])
                }
            }
        }

    }
    post {
        failure {
            script {
                if (isMasterBranch() || isReleaseBranch()) {
                    sendFailureMessage()
                }
            }
        }
    }
}

String getUpstreamProjects() {
    if (isMasterBranch() || isReleaseBranch()){
        return "alfa/${env.BRANCH_NAME},vorgang-manager/${env.BRANCH_NAME},user-manager/${env.BRANCH_NAME}"
    }

    return ""
}

def cloneGitopsRepo() {
    final email = "jenkins@ozg-sh.de"
    final name = "jenkins"

    withCredentials([usernamePassword(credentialsId: 'jenkins-gitea-access-token', passwordVariable: 'TOKEN', usernameVariable: 'USER')]) {
        sh 'git clone https://${USER}:${TOKEN}@git.ozg-sh.de/ozgcloud-devops/gitops.git'

        dir("gitops") {
            sh "git config user.email '${email}'"
            sh "git config user.name '${name}'"
        }
    }
}

Map getApplicationValues(String application) {
    def applicationValues = readYaml file: "gitops/${getEnvironment()}/application/values/${application}-values.yaml"

    return applicationValues.get(application.replaceAll("-", "_"))
}

String getEnvironment() {
    if (isReleaseBranch()) {
        return "test"
    }

    return "dev"
}

String getImageTag(Map applicationValues) {
    return applicationValues.image.tag
}

String getHelmChartVersion(Map applicationValues) {
    return applicationValues.helm.version
}

Void initEnvAlfaDefaultVersions() {
    if (isMasterBranch() || isReleaseBranch()) {
        values = getApplicationValues('alfa')

        env.ALFA_IMAGE_TAG = getImageTag(values)
        env.ALFA_HELM_CHART_VERSION = getHelmChartVersion(values)
    }
    else {
        env.ALFA_IMAGE_TAG = getFeatureBranchImageTag()
        env.ALFA_HELM_CHART_VERSION = getFeatureBranchHelmChartVersion()
    }

    env.ALFA_HELM_REPO_URL = getHelmRepoUrl()
}

Boolean isMasterBranch() {
    return env.BRANCH_NAME == 'master'
}

String getHelmRepoUrl() {
    if (isReleaseBranch()) {
        return "https://nexus.ozg-sh.de/repository/ozg-base-apps"
    }

    return "https://nexus.ozg-sh.de/repository/ozg-base-apps-snapshot"
}

String getFeatureBranchImageTag() {
    return "${env.BRANCH_NAME}-${getRootPomVersion()}"
}

String getFeatureBranchHelmChartVersion() {
    return "${getRootPomVersion()}-${env.BRANCH_NAME}".replaceAll("_", "-")
}

String getRootPomVersion() {
    def rootPom = readMavenPom file: 'pom.xml'

    return rootPom.version
}

Void initEnvVorgangManagerDefaultVersions() {
    def values = getApplicationValues('vorgang-manager')

    env.VORGANG_MANAGER_IMAGE_TAG = getImageTag(values)
    env.VORGANG_MANAGER_HELM_CHART_VERSION = getHelmChartVersion(values)
    env.VORGANG_MANAGER_HELM_REPO_URL = getHelmRepoUrl()
}

Void initEnvUserManagerDefaultVersions() {
    def values = getApplicationValues('user-manager')

    env.USER_MANAGER_IMAGE_TAG = getImageTag(values)
    env.USER_MANAGER_HELM_CHART_VERSION = getHelmChartVersion(values)
    env.USER_MANAGER_HELM_REPO_URL = getHelmRepoUrl()
}

Void initEnvUserVersions(userVersions) {
    env.ALFA_IMAGE_TAG = userVersions.AlfaImageTag
    env.ALFA_HELM_CHART_VERSION = userVersions.AlfaHelmChartVersion
    env.ALFA_HELM_REPO_URL = userVersions.AlfaHelmRepoUrl
    env.VORGANG_MANAGER_IMAGE_TAG = userVersions.VorgangManagerImageTag
    env.VORGANG_MANAGER_HELM_CHART_VERSION = userVersions.VorgangManagerHelmChartVersion
    env.VORGANG_MANAGER_HELM_REPO_URL = userVersions.VorgangManagerHelmRepoUrl
    env.USER_MANAGER_IMAGE_TAG = userVersions.UserManagerImageTag
    env.USER_MANAGER_HELM_CHART_VERSION = userVersions.UserManagerHelmChartVersion
    env.USER_MANAGER_HELM_REPO_URL = userVersions.UserManagerHelmRepoUrl
}


Void pushGitopsRepo() {
    withCredentials([usernamePassword(credentialsId: 'jenkins-gitea-access-token', passwordVariable: 'TOKEN', usernameVariable: 'USER')]) {
        dir('gitops') {
            if (hasUnpushedCommits()) {
                sh 'git config pull.rebase false'
                sh 'git pull'
                sh 'git push https://${USER}:${TOKEN}@git.ozg-sh.de/ozgcloud-devops/gitops.git'
            }
        }
    }
}

Boolean hasUnpushedCommits() {
    return sh (script: "git cherry -v | grep .", returnStatus: true) == env.SH_SUCCESS_STATUS_CODE as Integer
}

Void checkoutGitopsE2eBranch() {
    dir('gitops') {
        sh 'git checkout e2e'
    }
}

Void generateEaNamespaceYaml() {
    generateNamespaceYaml(env.EA_BEZEICHNER, "by-ea-dev.yaml");
}

Void generateMainNamespaceYaml() {
    generateNamespaceYaml(env.MAIN_BEZEICHNER, "by-main-dev.yaml");
}

Void generateNamespaceYaml(String bezeichner, String valuesPathSuffix) {
	def envValues
	dir('alfa-client/apps/alfa-e2e/') {
		envValues = readYaml file: "src/fixtures/argocd/" + valuesPathSuffix;

		envValues.ozgcloud.bezeichner = bezeichner
		envValues.alfa.put("image", ['tag': env.ALFA_IMAGE_TAG])
		envValues.alfa.put("helm", ['version': env.ALFA_HELM_CHART_VERSION, 'repoUrl': env.ALFA_HELM_REPO_URL])

		envValues.vorgang_manager.put("image", ['tag': env.VORGANG_MANAGER_IMAGE_TAG])
		envValues.vorgang_manager.put("helm", ['version': env.VORGANG_MANAGER_HELM_CHART_VERSION, 'repoUrl': env.VORGANG_MANAGER_HELM_REPO_URL])

		envValues.user_manager.put("image", ['tag': env.USER_MANAGER_IMAGE_TAG])
		envValues.user_manager.put("helm", ['version': env.USER_MANAGER_HELM_CHART_VERSION, 'repoUrl': env.USER_MANAGER_HELM_REPO_URL])
	}

    writeYaml file: "gitops/dev/namespace/namespaces/by-${bezeichner}-dev.yaml", data: envValues, overwrite: true

    sh "cat gitops/dev/namespace/namespaces/by-${bezeichner}-dev.yaml"

    dir("gitops") {
        sh "git add dev/namespace/namespaces/by-${bezeichner}-dev.yaml"
        sh "git commit -m 'add e2e by-${bezeichner}-dev'"
    }
}

Void deleteOzgCloudStack(ozgCloudBezeichner) {
    for(bezeichner in ozgCloudBezeichner) {
        if (hasNamespaceFile(bezeichner)) {
            removeNamespaceFile(bezeichner)
        }
    }

    pushGitopsRepo()

    for(bezeichner in ozgCloudBezeichner) {
        waitForDeletion(bezeichner)
    }
}

Void removeNamespaceFile(String bezeichner) {
    dir("gitops/dev/namespace/namespaces") {
        sh "rm by-${bezeichner}-dev.yaml"
        sh "git add by-${bezeichner}-dev.yaml"
        sh "git commit -m 'delete e2e by-${bezeichner}-dev.yaml'"
    }
}

Boolean hasNamespaceFile(String bezeichner) {
    return sh (script: "ls gitops/dev/namespace/namespaces | grep 'by-${bezeichner}-dev.yaml'", returnStatus: true) == env.SH_SUCCESS_STATUS_CODE as Integer
}

Void waitForDeletion(String bezeichner) {
    try {
        sh "kubectl wait --for=delete applications/by-${bezeichner}-dev-application -n argocd --timeout=900s"
    } catch (Exception e) {
        error("Application by-${bezeichner}-dev-application konnte nicht gelöscht werden")
    }
}

Void waitForOzgCloudStackRollout(ozgCloudBezeichner) {
    for(bezeichner in ozgCloudBezeichner) {
        waitForRollout(bezeichner)
    }
}

Void waitForRollout(String bezeichner) {
    waitForHealthyApplication(bezeichner, 'application')
    waitForHealthyApplication(bezeichner, 'vorgang-manager')
    waitForHealthyApplication(bezeichner, 'user-manager')
    waitForHealthyApplication(bezeichner, 'alfa')
    waitForHealthyApplication(bezeichner, 'administration')
    waitForHealthyApplication(bezeichner, 'admin-client')
}

Void waitForHealthyApplication(String bezeichner, String application) {
    try {
        def countRetry = 0
        def maxRetry = 24

        while (!isApplicationPresent(bezeichner, application) && countRetry < maxRetry ) {
            countRetry++
            sh "sleep 20"
        }

        if (!isApplicationHealthy(bezeichner, application)) {
            waitForHealthyStatus(bezeichner, application)
        }
    } catch (Exception e) {
        echo "waitForHealthyApplication Exception: ${e}"
        error("Application ${application} unhealthy")
    }
}

Boolean isApplicationPresent(String bezeichner, String application) {
    return sh (script: "kubectl get applications -n argocd | grep 'by-${bezeichner}-dev-${application}'", returnStatus: true) == env.SH_SUCCESS_STATUS_CODE as Integer
}

Boolean isApplicationHealthy(String bezeichner, String application) {
    return sh (script: "kubectl get application/by-${bezeichner}-dev-${application} -n argocd -o=jsonpath='{.status.health.status}' | grep Healthy", returnStatus: true) == env.SH_SUCCESS_STATUS_CODE as Integer
}

Void waitForHealthyStatus(String bezeichner, String application) {
    sh "kubectl wait --for=jsonpath='{.status.health.status}'=Healthy applications/by-${bezeichner}-dev-${application} -n argocd --timeout=900s"
}

Void publishAlfaE2ETestResult(String appVariant, String reportName) {
  publishE2ETestResult("alfa-e2e", appVariant, reportName);
}

Void publishAdminE2ETestResult() {
  publishE2ETestResult("admin-e2e", "main-tests", "Admin E2E-Tests main");
}

Void publishE2ETestResult(String appName, String appVariant, String reportName) {
  def reportDir = "alfa-client/apps/"+appName+"/reports/"+appVariant;

  publishHTML (
    target: [
      allowMissing: false,
      alwaysLinkToLastBuild: false,
      keepAll: true,
      reportDir: reportDir,
      reportFiles: 'report.html',
      reportName: reportName
    ]
  )
}

// runTests(env.EA_BEZEICHNER, 'alfa-e2e', 'einheitlicher-ansprechpartner', mongoDbPort, env.STAGE_NAME
// runTests(env.EA_BEZEICHNER, 'alfa-e2e', 'main-tests', mongoDbPort, env.STAGE_NAME
// runTests(env.EA_BEZEICHNER, 'admin-e2e', 'main-tests', mongoDbPort, env.STAGE_NAME
String runTests(String bezeichner, String appName, String appVariant, Integer dbPort, String stageName) {
  def config = generateCypressConfig(bezeichner, appName, appVariant, dbPort)
  try {
    dir('alfa-client'){
      sh "npm run cypress:version"
      sh "apps/run-tests.sh ${appName} ${appVariant} ${config}"
    }
  } catch (Exception e) {
    printNpmDebugLog()

    error("Fehler in Stage ${stageName}")
  }
}

Void printNpmDebugLog() {
    if (hasNpmDebugLog()) {
        sh "cat /root/.npm/_logs/*-debug.log"
    }
    else {
        echo "Npm debug log not found"
    }
}

String makeUrlConform(String input) {
    return input.replaceAll(/[^a-zA-Z0-9]+/, "").toLowerCase()
}

String generateBezeichner(String stage) {
    def branchName = makeUrlConform(env.BRANCH_NAME)
    def stageName = makeUrlConform(stage)

    return "${cutBranchNameForKeycloakRealm(branchName, stageName)}-${stageName}"
}

String cutBranchNameForKeycloakRealm(String branchName, String stageName) {
    final maxKeycloakRealmLength = 30

    def cutBranchNamePosition = maxKeycloakRealmLength - (stageName.length() + "${env.BUNDESLAND}---dev".length())

    return branchName.take(cutBranchNamePosition)
}

String generateCypressConfig(String bezeichner, String appName, String appVariant, Integer dbPort) {
  def namespace = generateNamespace(bezeichner)
  def configName = "cypress-ci-"+appVariant+".json"

  dir("alfa-client/apps/${appName}/"){
    def config = readJSON file: 'cypress-ci.json'

    def vorgangManagerDatabaseSecret = getVorgangManagerDatabaseSecret(namespace);
    def decodedPassword = decodeString(vorgangManagerDatabaseSecret.password);
    def parsablePassword = makePasswordUrlConform(decodedPassword);

    config.baseUrl = "https://${bezeichner}.${env.CLUSTER_BASE_URL}" as String
    config.env.dbUrl = "mongodb://${decodeString(vorgangManagerDatabaseSecret.username)}:${parsablePassword}@localhost:${dbPort}/admin?ssl=false&directConnection=true&socketTimeoutMS=30000&heartbeatFrequencyMS=10000" as String
    config.env.keycloakUrl = "https://${env.SSO_URL}/" as String
    config.env.keycloakRealm = namespace as String
    config.videosFolder = "./reports/${appVariant}/videos" as String
    config.screenshotsFolder = "./reports/${appVariant}/screenshots" as String
    config.reporterOptions.reportDir = "./reports/${appVariant}/mochawesome-report" as String

    config.specPattern = "src/e2e/${appVariant}/**/*.cy.{js,jsx,ts,tsx}" as String

    config.env.put("search", getElasticsearchEnv(namespace))
    config.env.put("userManager", getUserManagerEnv(namespace, dbPort))
    config.env.put("smocker", getSmockerEnv(namespace))

    writeJSON file: configName, json: config

    sh "cat ${configName}"
  }

  return "cypress-ci-"+appVariant+".config.ts"
}



String makePasswordUrlConform(String password) {
    return sh (script: "printf %s ${password} | jq -sRr @uri", returnStdout: true);
}

Map getVorgangManagerDatabaseSecret(String namespace) {
    return readJSON ( text: sh (script: "kubectl get secret ozg-mongodb-admin-vorgang-manager-user -n ${namespace} -o jsonpath={.data}", returnStdout: true))
}

Map getUserManagerEnv(String namespace, dbPort){
    def userManagerDatabaseSecret = getUserManagerDatabaseSecret(namespace);
    def decodedPassword = decodeString(userManagerDatabaseSecret.password);
    def parsablePassword = makePasswordUrlConform(decodedPassword);

    return [
        "dbUrl": "mongodb://${decodeString(userManagerDatabaseSecret.username)}:${parsablePassword}@localhost:${dbPort}/admin?ssl=false&directConnection=true&socketTimeoutMS=30000&heartbeatFrequencyMS=10000" as String,
        "database": "user-manager-database"
        ]
}

Map getUserManagerDatabaseSecret(String namespace) {
    return readJSON ( text: sh (script: "kubectl get secret ozg-mongodb-admin-user-manager-user -n ${namespace} -o jsonpath={.data}", returnStdout: true))
}

Void sendFailureMessage() {
    def data = [
        "msgtype": "m.text",
        "body": "E2E-Tests: Failed stage: ${getFailedStage()} Build-ID: ${env.BUILD_NUMBER} Link: ${BLUE_OCEAN_URL}" as String,
        "format": "org.matrix.custom.html",
        "formatted_body": "E2E-Tests: Failed stage: ${getFailedStage()} Build-ID: <a href='${BLUE_OCEAN_URL}'>${env.BUILD_NUMBER}</a>" as String
        ]

    sh "curl -XPOST -H 'authorization: Bearer ${getElementAccessToken()}' -d '${JsonOutput.toJson(data)}' https://matrix.ozg-sh.de/_matrix/client/v3/rooms/${getElementRoomId()}/send/m.room.message"
}

String getFailedStage() {
    if (FAILED_PARALLEL_STAGE.trim()) {
        return FAILED_PARALLEL_STAGE.trim()
    }

    return FAILED_STAGE
}

String getElementRoomId() {
    final releaseRoomId = "!oWZpUGTFsxkJIYNfYg:matrix.ozg-sh.de"
    final masterRoomId = "!iQPAvQIiRwRpNOszjw:matrix.ozg-sh.de"

    if (isReleaseBranch()) {
        return releaseRoomId
    }

    return masterRoomId
}

Boolean isReleaseBranch() {
    return env.BRANCH_NAME == 'release'
}

String getElementAccessToken() {
    withCredentials([string(credentialsId: 'element-login-json', variable: 'LOGIN_JSON')]) {
        return readJSON ( text: sh (script: '''curl -XPOST -d \"$LOGIN_JSON\" https://matrix.ozg-sh.de/_matrix/client/v3/login''', returnStdout: true)).access_token
    }
}

Map getElasticsearchEnv(String namespace) {
    def elasticsearchSecret = getElasticsearchSecret(namespace)

    return [
        "user": decodeString(elasticsearchSecret.username),
        "password": decodeString(elasticsearchSecret.password),
        "index": decodeString(elasticsearchSecret.index),
        "url": "https://localhost:9200"
        ]
}

Void forwardMongoDbPort(String namespace) {
    try {
        def minPort = 20000
        def portRange = 20000
        //def dbPort = "${Math.abs(new Random().nextInt(portRange+1))+minPort}" as Integer
        def dbPort = Math.abs(new Random().nextInt(portRange+1))+minPort

        echo "Forwarding MongoDB Port to local port ${dbPort}"

        def pidFile = generateMongoDbPortForwardPidFile(namespace)

        sh "kubectl port-forward ozg-mongodb-0 ${dbPort}:27017 -n ${namespace} & echo \$! > ${pidFile}"

        sh "sleep 20"

        return dbPort
    }
    catch (Exception e) {
        echo "forwardMongoDbPort Exception: ${e}"
        error("Error forwarding service")
    }
}

Void stopForwardMongoDbPort(String namespace) {
    echo "Removing forwarding MongoDB Port to local port for ${namespace}"
    def pidFile = generateMongoDbPortForwardPidFile(namespace)
    dir('alfa-client/apps/alfa-e2e/src/jenkins-build-files') {
        sh "./kill-pid-by-filename.sh ${pidFile}"
    }
}

Void generateMongoDbPortForwardPidFile(String namespace) {
    return "/tmp/pid_file_mongodb_port_forward_${namespace}.pid"
}

Void forwardElasticSearch() {
    if(!isElasticSearchForwarded()) {
        sh "kubectl port-forward ozg-search-cluster-es-ozg-search-0 9200:9200 -n elastic-system &"
    }
}

Boolean isElasticSearchForwarded() {
    return sh (script: "lsof -i -P -n | grep LISTEN | grep :9200", returnStatus: true) == env.SH_SUCCESS_STATUS_CODE as Integer
}

String generateNamespace(String bezeichner) {
    return "${env.BUNDESLAND}-${bezeichner}-dev"
}

String decodeString(String encoded) {
  return sh (script: "echo -n ${encoded} | base64 --decode", returnStdout: true)
}

Map getElasticsearchSecret(String namespace) {
    return readJSON ( text: sh (script: "kubectl get secret elasticsearch-credentials -n ${namespace} -o jsonpath={.data}", returnStdout: true))
}

Boolean hasNpmDebugLog() {
    return sh (script: "ls -l /root/.npm/_logs/*-debug.log", returnStatus: true) == env.SH_SUCCESS_STATUS_CODE as Integer
}

Map getSmockerEnv(String namespace) {
    return [
        "url": "https://${namespace}-smocker.dev.by.ozg-cloud.de".toString()
        ]
}