project.gradle

// Common configuration applied to all projects
import java.nio.file.*
import java.nio.file.attribute.*
import java.util.Set
import static org.apache.tools.ant.taskdefs.condition.Os.FAMILY_WINDOWS
import static org.apache.tools.ant.taskdefs.condition.Os.isFamily
import static org.jetbrains.gradle.ext.ShortenCommandLine.MANIFEST
import org.jetbrains.gradle.ext.Application
import org.jetbrains.gradle.ext.JUnit


// Configure versions in gradle.properties (putting a gradle.properties file
// in a subproject only overrides root properties of same name for the actual
// subproject, not for its children!)
version = hasProperty("openremoteVersion") ? openremoteVersion : "0.0.0"

// Ensure git hook creation task is executed
if (project == rootProject) {

    project.afterEvaluate {

        if (rootProject.hasProperty("gradleFileEncrypt")) {
            println("File encryption plugin config found, configuring git pre commit hook and decrypt task dependency")
            try {
                // Write git hook for encryption plugin checks before any commit
                def path = Paths.get(rootProject.projectDir.path, ".git/hooks/pre-commit")
                def f = path.toFile()
                f.text = """#!/bin/sh

echo "***** Running gradle encryption plugin checkFilesGitIgnored task ******"

./gradlew checkFilesGitIgnoredNew

status=\$?

exit \$status
"""
                Set<PosixFilePermission> perms = Files.readAttributes(path, PosixFileAttributes.class).permissions()
                perms.add(PosixFilePermission.OWNER_WRITE)
                perms.add(PosixFilePermission.OWNER_READ)
                perms.add(PosixFilePermission.OWNER_EXECUTE)
                perms.add(PosixFilePermission.GROUP_WRITE)
                perms.add(PosixFilePermission.GROUP_READ)
                perms.add(PosixFilePermission.GROUP_EXECUTE)
                perms.add(PosixFilePermission.OTHERS_READ)
                perms.add(PosixFilePermission.OTHERS_EXECUTE)
                Files.setPosixFilePermissions(path, perms)
            } catch (Exception ignored) {}

            // Add dependency on decrypt task for deployment installDist only if GFE_PASSWORD defined
            def password = System.env.GFE_PASSWORD
            if (password != null) {
                Task decryptTask = getTasksByName("decryptFiles", false)[0]

                try {
                    def installDist = tasks.getByPath(":deployment:installDist")
                    installDist.dependsOn decryptTask
                    installDist.mustRunAfter(decryptTask)
                } catch (Exception ex) {
                    println("Failed to add decryptFiles task dependency: " + ex)
                }
            }
        } else {
            // Remove git hook
            try {
                Files.delete(Paths.get(rootProject.projectDir.path, ".git/hooks/pre-commit"))
            } catch (Exception ignored) {
            }
        }
    }
}


// Configure Conditional plugins
if (project == rootProject) {
    apply plugin: "org.jetbrains.gradle.plugin.idea-ext"

    // Configure IDEA
    if (project.hasProperty("idea") && idea.project) {
        // IDEA settings
        idea.project.settings {
            compiler {
                javac {
                    javacAdditionalOptions "-parameters"
                }
            }
            runConfigurations {
                defaults(JUnit) {
                    shortenCommandLine = MANIFEST
                    workingDirectory = (isCustomProject() ? project(":openremote").projectDir.toString() : projectDir.toString())
                }
                defaults(Application) {
                    mainClass = 'org.openremote.manager.Main'
                    shortenCommandLine = MANIFEST
                    workingDirectory = (isCustomProject() ? project(":openremote").projectDir.toString() : projectDir.toString())
                }
                "Demo Setup"(Application) {
                    moduleName = getProject().idea.module.name + (isCustomProject() ? ".openremote.setup.demo" : ".setup.demo")
                    envs = [
                            OR_SETUP_TYPE: "demo"
                    ]
                }
                "Demo Setup with Proxy"(Application) {
                    moduleName = getProject().idea.module.name + (isCustomProject() ? ".openremote.setup.demo" : ".setup.demo")
                    envs = [
                            OR_SETUP_TYPE: "demo",
                            OR_WEBSERVER_LISTEN_HOST: "0.0.0.0",
                            OR_SSL_PORT: "-1"
                    ]
                }
                "Test Setup"(Application) {
                    moduleName = getProject().idea.module.name + (isCustomProject() ? ".openremote.setup.integration" : ".setup.integration")
                }
                "Test Setup with Proxy"(Application) {
                    moduleName = getProject().idea.module.name + (isCustomProject() ? ".openremote.setup.integration" : ".setup.integration")
                    envs = [
                            OR_WEBSERVER_LISTEN_HOST: "0.0.0.0",
                            OR_SSL_PORT: "-1"
                    ]
                }
                "Empty"(Application) {
                    moduleName = getProject().idea.module.name + (isCustomProject() ? ".openremote.manager.main" : ".manager.main")
                }
                "Empty with Proxy"(Application) {
                    moduleName = getProject().idea.module.name + (isCustomProject() ? ".openremote.manager.main" : ".manager.main")
                    envs = [
                            OR_WEBSERVER_LISTEN_HOST: "0.0.0.0",
                            OR_SSL_PORT: "-1"
                    ]
                }
            }
        }

        if (isCustomProject()) {
            idea.project.settings.runConfigurations {
                "Custom Deployment"(Application) {
                    moduleName = "${getProject().idea.module.name}.setup.main"
                    envs = [
                        OR_MAP_SETTINGS_PATH: "../deployment/map/mapsettings.json",
                        OR_MAP_TILES_PATH: "../deployment/map/mapdata.mbtiles",
                        OR_CUSTOM_APP_DOCROOT: "../deployment/manager/app",
                        OR_CONSOLE_APP_CONFIG_DOCROOT: "../deployment/manager/consoleappconfig"
                    ]
                }
            }
        }
    }
}

// Give test projects more memory (Gradle 5 reduced this to 512MB)
subprojects {
    tasks.withType(Test) {
        maxHeapSize = "2g"
    }
}

// Default repositories for dependency resolution
repositories {
    maven {
        url = "https://repo.osgeo.org/repository/release/"
    }
    mavenCentral()
    maven {
        url "https://pkgs.dev.azure.com/OpenRemote/OpenRemote/_packaging/OpenRemote/maven/v1"
    }
}

// Eclipse needs help
apply plugin: "eclipse"

// Intellij needs help
apply plugin: 'idea'
// Use the same output directories in IDE as in gradle
idea {
    module {
        outputDir file('build/classes/main')
        testOutputDir file('build/classes/test')
        excludeDirs += file(".node")
        excludeDirs += file("node_modules")
        excludeDirs += file("dist")
        excludeDirs += file("lib")
        excludeDirs += file("build")
    }
}



// Helper functions for project/task resolution when the main 
// repo is checked out as a git submodule and therefore a subproject
def isCustomProject() {
    findProject(":openremote") != null
}

def resolvePath(String path) {
    isCustomProject() ? ":openremote" + path : path
}

def resolveProject(String path) {
    project(resolvePath(path))
}

def resolveTask(String path) {
    tasks.getByPath(resolvePath(path))
}

def getYarnInstallTask() {
    if (isCustomProject()) {
        def customPackageJsonFile = Paths.get(rootProject.projectDir.path, "package.json").toFile()
        if (!customPackageJsonFile.exists()) {
            // No custom project yarn package.json so use standard openremote repo package.json
            return resolveTask(":yarnInstall")
        } else {
            return tasks.getByPath(":yarnInstall")
        }
    } else {
        // Just use openremote repo yarn install
        resolveTask(":yarnInstall")
    }
}

// Gets the list of runtime JAR dependencies; can be used in custom project deployment installDist task to populate
// extensions directory
def getDeploymentJars(Project project = project) {
    if (project.configurations.find { it.name == "runtimeClasspath" } == null) {
        return []
    }

    // Get all dependencies that are already part of the openremote manager and exclude these from the libs dir
    // otherwise they will appear on the classpath twice (once in manager app dir and then again in extensions)
    def excludeDependencies = resolveProject(":manager").configurations.runtimeClasspath.resolvedConfiguration.resolvedArtifacts

    return project.configurations.runtimeClasspath.resolvedConfiguration.resolvedArtifacts.findAll {
        dep -> excludeDependencies.find { it == dep } == null && dep.name != "openremote-manager" }.collect {
        println "CopyLibs Artifact: ${it.file.path}"
        return it.file
    }
}

ext {
    resolvePath = this.&resolvePath
    resolveProject = this.&resolveProject
    resolveTask = this.&resolveTask
    isCustomProject = this.&isCustomProject
    getYarnInstallTask = this.&getYarnInstallTask
    getDeploymentJars = this.&getDeploymentJars
}

// Add UI tasks
ext.npmCommand = {
    cmd ->
        isFamily(FAMILY_WINDOWS) ? "${cmd}.cmd" : cmd
}

// Add yarn tasks
task yarnInstall(type: Exec){
    commandLine npmCommand("yarn"), "install"
}
task yarnInstallForce(type: Exec){
    commandLine npmCommand("yarn"), "install", "--force"
}

task npmClean(type: Exec){
    dependsOn getYarnInstallTask()
    commandLine npmCommand("yarn"), "run", "clean"
}
task npmBuild(type: Exec){
    mustRunAfter npmClean
    dependsOn getYarnInstallTask()
    commandLine npmCommand("yarn"), "run", "build"
}
task npmTest(type: Exec){
    dependsOn getYarnInstallTask()
    commandLine npmCommand("yarn"), "run", "test"
}
task npmServe(type: Exec){
    dependsOn getYarnInstallTask()
    commandLine npmCommand("yarn"), "run", "serve"
}
task npmPrepare(type: Exec){
    dependsOn getYarnInstallTask()
    commandLine npmCommand("yarn"), "run", "prepublishOnly"
}
task npmPublish(type: Exec){
    dependsOn getYarnInstallTask()
    commandLine npmCommand("yarn"), "publish"
}
task npmServeProduction(type: Exec) {
    dependsOn getYarnInstallTask()
    commandLine npmCommand("yarn"), "run", "serveProduction"
}

// Add typescript tasks
task tscWatch(type: Exec) {
    commandLine npmCommand("npx"), "tsc", "-b", "--watch"
}

// Configure Java build
plugins.withType(JavaPlugin).whenPluginAdded {

    // Use Java 17
    tasks.withType(JavaCompile) {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
        def warnLogFile = file("$buildDir/${name}Warnings.log")
        logging.addStandardErrorListener(new StandardOutputListener() {
            void onOutput(CharSequence output) {
                warnLogFile << output
            }
        })
        options.compilerArgs += ["-Xlint:unchecked", "-Xlint:deprecation", "-parameters"]
        options.encoding = 'UTF-8'
    }

    // JAR/ZIP base name is the fully qualified subproject name
    archivesBaseName = "${rootProject.name}${path.replaceAll(":", "-")}"
}

// POM generator