the-tip-top-backend/Jenkinsfile

pipeline {
    agent any

    triggers {
        pollSCM('* * * * *')
    }

    parameters {
        choice(
            name: 'ENV',
            choices: ['dev', 'preprod', 'prod'],
            description: 'Choisir l environnement de deploiement'
        )
    }

    environment {
        REGISTRY_URL = "registry.wk-archi-o24a-15m-g3.fr"
        IMAGE_NAME = "the-tip-top-backend"
        NPM_CACHE = "/var/jenkins_home/npm-cache"
    }

    stages {

        stage('Init') {
            steps {
                script {
                    def currentBranch = sh(script: "git rev-parse --abbrev-ref HEAD", returnStdout: true).trim()
                    echo "🧭 Branche détectée : ${currentBranch}"

                    if (["dev", "preprod", "main"].contains(currentBranch)) {
                        env.ENV = (currentBranch == "main") ? "prod" : currentBranch
                    } else {
                        env.ENV = params.ENV ?: "dev"
                    }

                    env.TAG = "${env.ENV}-latest"
                    env.DEPLOY_PATH = "/srv/devops/the-tip-top/${env.ENV}"

                    echo """
                    🌍 Environnement = ${env.ENV}
                    🏷️ Tag Docker = ${env.TAG}
                    📂 Chemin de déploiement = ${env.DEPLOY_PATH}
                    """
                }
            }
        }

        stage('Checkout') {
            steps {
                echo "📦 Récupération du code source..."
                checkout scm
            }
        }

        stage('Install Dependencies') {
            agent {
                docker {
                    image 'node:18-alpine'
                    args "-u root -v ${NPM_CACHE}:/root/.npm"
                }
            }
            steps {
                echo "📦 Installation des dépendances..."
                sh 'npm ci --prefer-offline'
                stash includes: 'node_modules/**', name: 'node_modules'
            }
        }

        stage('Quality Checks') {
            parallel {
                stage('Lint & Tests') {
                    agent {
                        docker {
                            image 'node:18-alpine'
                            args "-u root -v ${NPM_CACHE}:/root/.npm"
                        }
                    }
                    steps {
                        unstash 'node_modules'
                        echo "🧪 Lancement des tests et lint..."
                        script {
                            def lintStatus = sh(script: 'npm run lint', returnStatus: true)
                            def testStatus = sh(script: 'npm test', returnStatus: true)

                            if (lintStatus != 0) {
                                error "❌ ESLint a échoué"
                            }
                            if (testStatus != 0) {
                                error "❌ Les tests ont échoué"
                            }
                            echo "✅ Tests et lint passés"
                        }
                    }
                }

                stage('SonarQube') {
                    agent {
                        docker {
                            image 'sonarsource/sonar-scanner-cli:latest'
                            args '-u root'
                        }
                    }
                    steps {
                        echo "🔍 Analyse SonarQube..."
                        withSonarQubeEnv('SonarQube') {
                            sh """
                                sonar-scanner
                            """
                        }
                    }
                }
            }
        }

        stage('Build Docker image') {
            steps {
                echo "🐳 Construction de l'image Docker backend..."
                sh """
                    docker build -t ${REGISTRY_URL}/${IMAGE_NAME}:${TAG} .
                    docker tag ${REGISTRY_URL}/${IMAGE_NAME}:${TAG} ${REGISTRY_URL}/${IMAGE_NAME}:latest
                """
            }
        }

        stage('Push to Registry') {
            steps {
                echo "📤 Envoi de l'image vers le registre..."
                withCredentials([usernamePassword(credentialsId: 'registry-credentials', usernameVariable: 'REG_USER', passwordVariable: 'REG_PASS')]) {
                    sh """
                        echo "$REG_PASS" | docker login ${REGISTRY_URL} -u "$REG_USER" --password-stdin
                        docker push ${REGISTRY_URL}/${IMAGE_NAME}:${TAG}
                        docker push ${REGISTRY_URL}/${IMAGE_NAME}:latest
                    """
                }
            }
        }

        stage('Backup DB') {
            when {
                expression { env.ENV == 'prod' }
            }
            steps {
                echo "💾 Backup de la base de données avant déploiement..."
                sh """
                    /srv/devops/the-tip-top/backup.sh || echo "⚠️ Backup échoué mais on continue"
                """
                echo "✅ Backup terminé"
            }
        }

        stage('Deploy') {
            steps {
                echo "🚀 Déploiement sur ${env.ENV}..."
                sh """
                    cd "${DEPLOY_PATH}"
                    docker compose pull backend
                    docker compose up -d --force-recreate backend
                """
            }
        }
    }

    post {
        success {
            echo "✅ Pipeline ${env.ENV} terminé avec succès !"
        }
        failure {
            echo "❌ Échec du pipeline ${env.ENV}."
        }
    }
}