build.gradle

ext {
    println("Environment          : JAVA_HOME=$System.env.JAVA_HOME")
    println("Gradle Version       : ${projectProperties.getProperty('gradleVersion')}")
    println("Target JDK Version   : ${projectProperties.getProperty('javaVersion')}")
    println("Kotlin Version       : $versions.kotlin")
    println("Spring Boot Version  : $versions.springBoot")
    println("Acp Version          : $versions.acp")
    println("Encoding             : ${projectProperties.getProperty('encoding')}")
    println("Build Version        : ${projectProperties.getProperty('version')}")
}

buildscript {
    ext {
        projectProperties = new Properties()
        projectProperties.load(new FileInputStream("$rootDir/project.properties"))
    }
    apply from: "$rootDir/gradle/dependencies.gradle"
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$versions.kotlin"
        classpath "org.jetbrains.kotlin:kotlin-allopen:$versions.kotlin"
        classpath "org.jetbrains.kotlin:kotlin-noarg:$versions.kotlin"
        classpath "org.springframework.boot:spring-boot-gradle-plugin:$versions.springBoot"
    }
    repositories {
        mavenLocal()
        maven {
            url = new URI(projectProperties.getProperty('mavenCentralUrl').toString())
            allowInsecureProtocol = true
        }
        mavenCentral()
    }
}

allprojects {

    group project.group.toString().isBlank() ? projectProperties.getProperty('group') : "${projectProperties.getProperty('group')}.$project.group"
    version projectProperties.getProperty('version')

    apply from: "$rootDir/gradle/dependencies.gradle"

    apply plugin: 'java'
    apply plugin: 'kotlin'
    apply plugin: 'kotlin-kapt'
    apply plugin: 'kotlin-spring'
    apply plugin: 'kotlin-noarg'
    apply plugin: 'kotlin-jpa'
    apply plugin: 'idea'
    apply plugin: 'maven-publish'
    apply plugin: 'signing'

    apply from: "$rootDir/gradle/environment.gradle"

    sourceCompatibility = projectProperties.getProperty('javaVersion')
    targetCompatibility = projectProperties.getProperty('javaVersion')

    buildscript {
        repositories {
            mavenLocal()
            maven {
                url = new URI(projectProperties.getProperty('mavenCentralUrl').toString())
                allowInsecureProtocol = true
            }
            mavenCentral()
        }
    }

    repositories {
        mavenLocal()
        maven {
            url = new URI(projectProperties.getProperty('mavenCentralUrl').toString())
            allowInsecureProtocol = true
        }
        mavenCentral()
    }

    dependencies {
        testImplementation("org.junit.jupiter:junit-jupiter:$versions.jupiter")
        testImplementation("org.junit.platform:junit-platform-launcher:$versions.junitPlatform")
        testImplementation "org.jetbrains.kotlin:kotlin-test"
        testImplementation "org.jetbrains.kotlin:kotlin-test-junit5"
        implementation "org.jetbrains.kotlin:kotlin-stdlib"
        implementation "org.jetbrains.kotlin:kotlin-reflect"
        implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$versions.kotlinCoroutines"
    }

    task clearPj(type: Delete) {
        delete 'release', 'build', 'target', 'out'
    }

    task copyJar(type: Copy) {
        from(configurations.runtimeClasspath)
        into('build/libs/dependencies')
    }

    task mapperFileCopy(type: Copy) {
        copy {
            from("src/main/java") {
                include("**/*.xml")
                include("**/*.json")
                include("**/*.properties")
            }
            into("${buildDir}/classes/main")
        }
        copy {
            from("src/test/java") {
                include("**/*.xml")
                include("**/*.json")
                include("**/*.properties")
            }
            into("${buildDir}/classes/test")
        }
        copy {
            from("src/main/kotlin") {
                include("**/*.xml")
                include("**/*.json")
                include("**/*.properties")
            }
            into("${buildDir}/classes/main")
        }
        copy {
            from("src/test/kotlin") {
                include("**/*.xml")
                include("**/*.json")
                include("**/*.properties")
            }
            into("${buildDir}/classes/test")
        }
    }

    jar {
        dependsOn(copyJar)
        manifest {
            attributes('Implementation-Vendor': "${project.group}", 'Implementation-Title': "${project.name}", 'Implementation-Version': "${project.version}", 'Build-By': "Gradle ${projectProperties.getProperty('gradleVersion')}", 'Jvm-Version': "${projectProperties.getProperty('javaVersion')}", 'Kotlin-Version': "$versions.kotlin")
        }
    }

    java {
        withJavadocJar()
        withSourcesJar()
    }

    javadoc {
        options.charSet = projectProperties.getProperty('encoding')
        options.docEncoding = projectProperties.getProperty('encoding')
        options.encoding = projectProperties.getProperty('encoding')
        options.addStringOption('Xdoclint:none', '-quiet')
    }

    compileJava {
        options.encoding = projectProperties.getProperty('encoding')
    }
    compileJava.dependsOn(processResources)
    compileTestJava {
        options.encoding = projectProperties.getProperty('encoding')
    }

    compileKotlin {
        kotlinOptions {
            jvmTarget = projectProperties.getProperty('javaVersion')
        }
    }
    compileKotlin.dependsOn(processResources)
    compileTestKotlin {
        kotlinOptions {
            jvmTarget = projectProperties.getProperty('javaVersion')
        }
    }

    test {
        useJUnitPlatform()
        exclude '**/*nobuild**'
    }

    def generateShell = { String appJarName ->
        def memoryParam = jvmMemoryParam.get('default') as String
        // generate linux shell
        File templateFile = new File("$rootDir/doc/script/server.model")
        List<String> lines = templateFile.readLines("UTF-8")
        StringBuilder buffer = new StringBuilder()
        for (String line : lines) {
            buffer.append(line).append("\n")
        }
        String shellContent = buffer.toString()
        shellContent = shellContent.replaceAll("@appJarName@", appJarName)
        shellContent = shellContent.replaceAll("@jvmMemoryParam@", memoryParam)
        StringBuilder jvmExtParamBuilder = new StringBuilder()
        jvmExtParamBuilder.append("'")
        if (project.hasProperty("active") && project.active != null && project.active != "") {
            println("$project.name release finished: active=$project.active")
            def envParam = jvmExtParam.get(project.active)
            if (envParam != null) {
                jvmExtParamBuilder.append("-Dacp_profile_active=$project.active" as String)
                jvmExtParamBuilder.append(" -Dacp_nacos_addr=" + envParam['acp_nacos_addr'] as String)
                jvmExtParamBuilder.append(" -Dacp_nacos_username=" + envParam['acp_nacos_username'] as String)
                jvmExtParamBuilder.append(" -Dacp_nacos_password=" + envParam['acp_nacos_password'] as String)
                jvmExtParamBuilder.append(" -Dacp_nacos_namespace=" + envParam['acp_nacos_namespace'] as String)
                jvmExtParamBuilder.append(" -Dacp_log_path=" + envParam['acp_log_path'] as String)
            }
        }
        jvmExtParamBuilder.append("'")
        shellContent = shellContent.replaceAll("@jvmExtParam@", jvmExtParamBuilder.toString())
        File outFile = new File("$rootDir/release/$project.name/server.sh")
        Writer writer = new FileWriter(outFile)
        writer.write(new String(shellContent.getBytes("UTF-8")))
        writer.flush()
        writer.close()

        // generate k8s shell
        File templateFileK8s = new File("$rootDir/doc/script/server-k8s.model")
        List<String> linesK8s = templateFileK8s.readLines("UTF-8")
        StringBuilder bufferK8s = new StringBuilder()
        for (String line : linesK8s) {
            bufferK8s.append(line).append("\n")
        }
        String shellContentK8s = bufferK8s.toString()
        shellContentK8s = shellContentK8s.replaceAll("@appJarName@", appJarName)
        shellContentK8s = shellContentK8s.replaceAll("@jvmMemoryParam@", memoryParam)
        File outFileK8s = new File("$rootDir/release/$project.name/server-k8s.sh")
        Writer writerK8s = new FileWriter(outFileK8s)
        writerK8s.write(new String(shellContentK8s.getBytes("UTF-8")))
        writerK8s.flush()
        writerK8s.close()
    } as Object

    build {
        doLast {
            def needCopy = {
                return ["admin-server",
                        "deploy-server",
                        "gateway-server",
                        "log-server",
                        "oauth-server",
                        "workflow-server",
                        "route-server"].toArray().contains("$project.name")
            } as Object
            if (needCopy()) {
                def fileName = "$project.name" + "-" + "$project.version" + ".jar"
                copy {
                    from file("${buildDir}/libs/" + fileName)
                    into "$rootDir/release/$project.name"
                }
                copy {
                    from "${buildDir}/resources/main"
                    into "$rootDir/release/$project.name"
                }
                generateShell(fileName)
            }
        }
    }
    publishing {
        publications {
            maven(MavenPublication) {
                //指定group/artifact/version信息
                groupId project.group
                artifactId project.name
                version project.version
                //打包类型 war: components.web jar: components.java
                from components.java
                pom {
                    name = "acp-admin-cloud"
                    description = "基于acp构建的cloud应用"
                    url = "https://github.com/zhangbinhub/acp-admin-cloud"
                    licenses {
                        license {
                            name = "Apache License Version 2.0"
                            url = "http://www.apache.org/licenses/LICENSE-2.0"
                        }
                    }
                    developers {
                        developer {
                            id = "hangbinhub"
                            name = "zhangbin"
                            email = "zhangbin1010@qq.com"
                        }
                    }
                    scm {
                        connection = "scm:git:https://github.com/zhangbinhub/acp-admin-cloud.git"
                        developerConnection = "scm:git:https://github.com/zhangbinhub/acp-admin-cloud.git"
                        url = "https://github.com/zhangbinhub/acp-admin-cloud"
                    }
                }
            }
        }
        repositories {
            maven {
                def file = new File("$rootDir/gradle.properties")
                def releaseUrl = 'http://maven/repository'
                def snapshotUrl = 'http://maven/repository'
                def name = ''
                def pwd = ''
                if (file.exists()) {
                    def gradleProperties = new Properties()
                    gradleProperties.load(new FileInputStream(file))
                    releaseUrl = gradleProperties.containsKey('mavenUploadUrlRelease') ? "${mavenUploadUrlRelease}" : releaseUrl
                    snapshotUrl = gradleProperties.containsKey('mavenUploadUrlSnapshot') ? "${mavenUploadUrlSnapshot}" : snapshotUrl
                    name = gradleProperties.containsKey('mavenUserName') ? "${mavenUserName}" : name
                    pwd = gradleProperties.containsKey('mavenUserName') ? "${mavenPassword}" : pwd
                }
                url = version.endsWith('-SNAPSHOT') ? new URI(snapshotUrl) : new URI(releaseUrl)
                allowInsecureProtocol = true
                //认证用户和密码
                credentials {
                    username name
                    password pwd
                }
            }
        }
    }
    signing {
        required {
            def file = new File("$rootDir/gradle.properties")
            if (file.exists()) {
                def gradleProperties = new Properties()
                gradleProperties.load(new FileInputStream(file))
                if (!gradleProperties.getProperty('signing.keyId', '').isBlank()) {
                    return true
                }
            }
            return false
        }
        sign publishing.publications.maven
    }

    task release(dependsOn: [build, copyJar])

    def needDeployProject = {
        return ["acp-admin-cloud-constant",
                "acp-admin-cloud-dependencies"].toArray().contains("$project.name")
    } as Object

    publish.onlyIf { needDeployProject() }
    generateMetadataFileForMavenPublication.onlyIf { needDeployProject() }
    generatePomFileForMavenPublication.onlyIf { needDeployProject() }
    publishAllPublicationsToMavenRepository.onlyIf { needDeployProject() }
    publishMavenPublicationToMavenLocal.onlyIf { needDeployProject() }
    publishMavenPublicationToMavenRepository.onlyIf { needDeployProject() }
    publishToMavenLocal.onlyIf { needDeployProject() }
}