build.gradle

import java.nio.file.Files
import java.nio.file.Paths

def resourcePaths = new HashSet<File>();

def getDate() {
    def date = new Date()
    def formattedDate = date.format('yyyyMMdd.HHmmss')
    return formattedDate
}

ext.getCurrentBranchName = {
    new ByteArrayOutputStream().withStream { os ->
        exec {
            executable = "git"
            args = ["rev-parse", "--abbrev-ref", "HEAD"]
            standardOutput = os
        }
        return os.toString().replaceAll("\n", "")
    }
}

allprojects {
    def releaseURL = "http://artifactory.mycore.de/mycore-releases"
    def snapshotsURL = "http://artifactory.mycore.de/mycore-snapshots"
    def sonatypeSnapshotsURL = "https://oss.sonatype.org/content/repositories/snapshots"

    repositories {
        mavenLocal()

        mavenCentral()

        maven { url releaseURL }

        maven { url sonatypeSnapshotsURL }

        maven { url snapshotsURL }

        jcenter()
    }
}

subprojects {
    apply plugin: 'java'
    apply plugin: 'maven'
    apply plugin: 'eclipse'
    apply plugin: 'idea'

    sourceCompatibility = javaVersion
    targetCompatibility = javaVersion

    tasks.withType(JavaCompile) {
        options.encoding = 'UTF-8'
    }

    eclipse {
        jdt {
            sourceCompatibility = javaVersion
            targetCompatibility = javaVersion
        }
        classpath { downloadSources = true }
    }

    idea {
        module {
            downloadJavadoc = true
            downloadSources = true
        }
    }

    configurations { deployerJars }

    if (project.hasProperty('mavenUser') && project.hasProperty('mavenPassword')) {
        uploadArchives {
            repositories.mavenDeployer {
                repository(url: "http://artifactory.mycore.de/libs-${project.version.endsWith('-SNAPSHOT') ? 'snapshots' : 'releases'}-local") {
                    authentication(userName: mavenUser, password: mavenPassword)
                }
            }
        }
    }

    dependencies {
        testCompile 'org.jmockit:jmockit:1.46'
        testCompile 'junit:junit:4.12'
        testCompile 'com.github.tomakehurst:wiremock:1.57'
        testCompile 'org.apache.logging.log4j:log4j-api:$log4jVersion'
        testCompile 'org.apache.logging.log4j:log4j-core:$log4jVersion'
        testCompile 'org.seleniumhq.selenium:selenium-java:2.53.0'
        testCompile 'org.glassfish.jersey.test-framework:jersey-test-framework-core:2.30.1'
        testCompile 'org.glassfish.jersey.test-framework.providers:jersey-test-framework-provider-grizzly2:2.30.1'
        testCompile 'org.glassfish.jersey.bundles.repackaged:jersey-guava:2.25.1'


    }

    if (project.name != 'jportal_webapp') {
        resourcePaths.addAll(sourceSets.main.resources.srcDirs);
    }

    test {
        systemProperty "project.buildDir", project.buildDir.absolutePath
    }

    ext.mcrModule = {
        jar {
            manifest {
                attributes("MCR-Application-Module": "$project.name")
                attributes("MCR-Artifact-Id": "$project.name")
                attributes("version": "$project.version")
                attributes("branch": getCurrentBranchName())
                attributes("timestamp": getDate())
            }
        }
    }

    jar.doLast {
        copy {
            from "$project.buildDir/tmp/jar"
            include "MANIFEST.MF"
            into "$project.buildDir/resources/main/META-INF"
        }
    }

    compileJava {
        options.compilerArgs << '-Xlint:deprecation'
        //options.compilerArgs << '-Xlint:unchecked'
    }

}

project(':jportal_mcr_module') {

    mcrModule()

    configurations.all {
        resolutionStrategy {
            force "org.apache.logging.log4j:log4j-api:$log4jVersion"
            force "org.apache.logging.log4j:log4j-core:$log4jVersion"
        }
    }

    dependencies {
        // test
        testCompile 'org.mycore:mycore-base:$mcrVersion:tests'
        testCompile 'org.hibernate:hibernate-hikaricp:5.2.2.Final'
        testCompile 'com.h2database:h2:1.4.197'

        compile project(":jportal_libs")

        // mycore
        compile "org.mycore:mycore-base:$mcrVersion"
        compile "org.mycore:mycore-solr:$mcrVersion"
        compile "org.mycore:mycore-iview2:$mcrVersion"
        compile "org.mycore:mycore-viewer:$mcrVersion"
        compile "org.mycore:mycore-user2:$mcrVersion"
        compile "org.mycore:mycore-classeditor:$mcrVersion"
        compile "org.mycore:mycore-mets:$mcrVersion"
        compile "org.mycore:mycore-oai:$mcrVersion"
        compile "org.mycore:mycore-impex:$mcrVersion"
        compile "org.mycore:mycore-webtools:$mcrVersion"
        compile "org.mycore:mycore-webcli:$mcrVersion"
        compile "org.mycore:mycore-pi:$mcrVersion"
        compile "org.mycore:mycore-iiif:$mcrVersion"
        compile "org.mycore:mycore-migration:$mcrVersion"
        compile "org.mycore:mycore-xeditor:$mcrVersion"

        // mycore external
        compile 'org.mycore.sru:sru-adapter:0.0.1-SNAPSHOT'
        compile 'org.mycore.mets:mets-model:0.13-SNAPSHOT'
        compile 'org.mycore.mets:mets-validator:1.3-SNAPSHOT'

        // thulb libs
        compile 'fsu.archiv.mycore.sru:sru-pica-import:0.0.2-SNAPSHOT'

        // external libs
        compile 'javax.servlet:javax.servlet-api:3.1.0'
        compile "org.apache.logging.log4j:log4j-api:$log4jVersion"
        compile "org.apache.logging.log4j:log4j-core:$log4jVersion"
        compile "org.glassfish.jersey.test-framework:jersey-test-framework-core:$jerseyVersion"
        compile "org.glassfish.jersey.core:jersey-server:$jerseyVersion"
        compile group: 'org.eclipse.persistence', name: 'org.eclipse.persistence.moxy', version: '2.7.4'
        compile group: 'org.glassfish.jersey.media', name: 'jersey-media-moxy', version: '2.29'
        compile group: 'javax.json', name: 'javax.json-api', version: '1.1.4'
        compile group: 'org.glassfish', name: 'javax.json', version: '1.1.4'
//        compile group: 'org.eclipse.persistence', name: 'eclipselink', version: '2.7.4'
//         compile "org.glassfish.jersey.core:jersey-client:$jerseyVersion"
//         compile "org.glassfish.jersey.inject:jersey-hk2:$jerseyVersion"
        compile 'org.easymock:easymock:3.2'
        compile 'xmlunit:xmlunit:1.3'
        compile "javax.xml.bind:jaxb-api:$jaxbVersion"
        compile 'com.google.inject:guice:4.1.0'
        compile 'org.marc4j:marc4j:2.8.2'
        compile 'com.neovisionaries:nv-i18n:1.23'

        // webjars
        compile 'org.webjars.bower:jquery:2.1.4'
        compile 'org.webjars:jquery-ui:1.11.4'
        compile 'org.webjars:cowwoc-jquery-address:1.6'
        compile 'org.webjars:bootstrap:3.3.4'
        compile 'org.webjars:Eonasdan-bootstrap-datetimepicker:4.15.35'
        compile 'org.webjars.npm:bootstrap3-dialog:1.35.4'
        compile 'org.webjars:mustachejs:0.8.2'
        compile 'org.webjars:ckeditor:4.7.0'
        compile 'org.webjars:font-awesome:5.12.0'
        compile 'org.webjars:momentjs:2.10.6'
        compile 'org.webjars:highstock:2.0.4'
    }

}

project(':jportal_acl_ip_editor_module') {
    dependencies {
        compile project(':jportal_mcr_module')
    }
}

project(':jportal_derivate_browser') {
    mcrModule()
    dependencies {
        compile project(':jportal_mcr_module')
    }
}

project(':jportal_move_obj_module') {
    mcrModule()
    dependencies {
        compile project(':jportal_mcr_module')
    }
}

project(':jportal_doublet_finder_module') {
    mcrModule()
    dependencies {
        compile project(':jportal_mcr_module')
    }
}

project(':jportal_laws') {
    mcrModule()
    dependencies {
        compile project(':jportal_mcr_module')
    }
}

project(':jportal_IT-TestData') {
    mcrModule()
    dependencies {
        compile project(':jportal_mcr_module')
    }
}

project(':jportal_webapp') {
    apply plugin: 'war'

    configurations {
        runtime.exclude group: "org.slf4j", module: "slf4j-nop"
        runtime.exclude group: "com.zaxxer", module: "HikariCP-java6"
    }

    configurations.all {
        resolutionStrategy {
            force "org.apache.logging.log4j:log4j-api:$log4jVersion"
            force "org.apache.logging.log4j:log4j-core:$log4jVersion"
        }
    }

    dependencies {
        testCompile 'junit:junit:4.12'
        testCompile "org.apache.logging.log4j:log4j-core:$log4jVersion"
        testCompile "org.hamcrest:hamcrest-library:1.3"
        testCompile 'org.seleniumhq.selenium:selenium-java:2.53.0'
        testCompile "org.mycore:selenium-utils:$seleniumUtilsVersion"

        runtime "org.apache.logging.log4j:log4j-web:$log4jVersion"
        runtime "org.mycore:mycore-xeditor:$mcrVersion"
        runtime "org.mycore:mycore-webcli:$mcrVersion"
        runtime "org.mycore:mycore-acl-editor2:$mcrVersion"
        runtime "org.mycore:mycore-ifs:$mcrVersion"
		runtime "com.zaxxer:HikariCP:2.7.8"
		runtime "org.hibernate:hibernate-hikaricp:$hibernateVersion"

        runtime project(':jportal_laws')
        runtime project(':jportal_derivate_browser')
        runtime project(':jportal_doublet_finder_module')
        runtime project(':jportal_move_obj_module')
        runtime project(':jportal_acl_ip_editor_module')
        runtime project(':jportal_mcr_module')
    }

    war {
        manifest {
            attributes("Webapp": "$project.name")
            attributes("version": "$project.version")
        }
    }

    // don't run webtests at compile time
    test {
        exclude '**/test'
    }

    // Webapp runner tasks
    configurations {
        h2db
        printer
    }

    dependencies {
        h2db "com.h2database:h2:1.4.197"
    }

    ext.appName = "jportal"
    ext.mcrHome = System.getProperty("user.home") + "/.mycore"

    if(project.hasProperty('mycoreHome')){
        ext.mcrHome = project.property("mycoreHome");
        println "Set mycore Home to " + mcrHome;
    }

    ext.appPath = "$mcrHome/$appName"
    ext.confDir = "$project.projectDir/config"
    ext.solrPort = '8391'
    ext.jettyStopPort = '8296'
    ext.jettyStopKey = 'StopJetty'


    def solrBasePath = Paths.get(projectDir.getAbsolutePath(), "solr");
    def solrZipFile = solrBasePath.resolve("solr-${solrVersion}.zip");
    def solrServerPath = solrBasePath.resolve("server");
    def mcrHomeLibPath = Paths.get("$appPath/lib");

    def tomcatBasePath = Paths.get(projectDir.getAbsolutePath(), "tomcat");
    def tomcatZipURLObj = new URL(tomcatZipURL);
    def tomcatURLPath = tomcatZipURLObj.getPath();
    def pathParts = tomcatURLPath.split("/");
    def tomcatZipFile = tomcatBasePath.resolve(pathParts[pathParts.length - 1]);
    def tomcatServerPath = tomcatBasePath.resolve("server");

    task configTomcat {
        doLast {

            //Tomcat
            if (!Files.exists(tomcatBasePath)) {
                Files.createDirectory(tomcatBasePath);
            }
            def newTomcatVersion = false;
            if (!Files.exists(tomcatZipFile)) {
                tomcatZipURLObj.withInputStream { is -> tomcatZipFile.withOutputStream { it << is } }
                newTomcatVersion = true;
            }

            // extract
            if (!Files.exists(tomcatServerPath) || newTomcatVersion) {
                if (Files.exists(tomcatServerPath) && newTomcatVersion) {
                    println "There is probably a new Tomcat version. Delete old folder..."
                    delete tomcatServerPath.toAbsolutePath().toString()
                }
                println "Tomcat not installed. Installing into " + tomcatServerPath + "..."
                Files.createDirectories(tomcatServerPath);
                def ignoreRootDir = tomcatZipFile.getFileName().toString().replaceAll(".zip","");
                copy {
                    from zipTree(tomcatZipFile.toAbsolutePath().toString()).matching { include "$ignoreRootDir/**" }
                    fileMode 0757
                    into tomcatServerPath.toAbsolutePath().toString()
                    eachFile { fcp ->
                        fcp.path = fcp.path.replaceFirst("^$ignoreRootDir", '')
                    }
                    includeEmptyDirs false
                }
            }

            def confFolder = tomcatServerPath.resolve("conf").toString()
            copy {
                from file("$confDir/tomcat/server.xml")
                into confFolder
            }
        }
    }
    
    task linkWar(type: Exec) {
        workingDir tomcatServerPath.resolve("webapps")
        def archivePath = war.destinationDirectory.get().toString() + "/" + war.archiveFileName.get(); 
        commandLine 'ln', '-sf', archivePath, './jportal.war'
    }

    configTomcat.finalizedBy linkWar

    task configApp {
        doLast {
            // copy config/*
            copy {
                from(confDir) {
                    include "**"
                    exclude "**/tomcat"
                }
                into appPath
            }

            // handle SOLR
            // download
            if (!Files.exists(solrBasePath)) {
                Files.createDirectory(solrBasePath);
            }
            def newVersion = false;
            if (!Files.exists(solrZipFile)) {
                def solrZipURL = "${solrMirror}/${solrVersion}/solr-${solrVersion}.zip"
                new URL(solrZipURL).withInputStream { is -> solrZipFile.withOutputStream { it << is } }
                newVersion = true;
            }

            // extract
            if (!Files.exists(solrServerPath) || newVersion) {
                if (Files.exists(solrServerPath) && newVersion) {
                    println "There is probably a new solr version. Delete old folder..."
                    delete solrServerPath.toAbsolutePath().toString()
                }
                println "Solr not installed. Installing into " + solrServerPath + "..."
                Files.createDirectories(solrServerPath);
                def ignoreRootDir = 'solr-' + solrVersion
                copy {
                    from zipTree(solrZipFile.toAbsolutePath().toString()).matching { include "$ignoreRootDir/**" }
                    into solrServerPath.toAbsolutePath().toString()
                    eachFile { fcp ->
                        fcp.path = fcp.path.replaceFirst("^$ignoreRootDir", '')
                    }
                    includeEmptyDirs false
                }
            }
            
            if (!Files.exists(mcrHomeLibPath)){
                Files.createDirectory(mcrHomeLibPath);
                copy {
                    from configurations.h2db.asPath.toString()
                    into mcrHomeLibPath.toAbsolutePath().toString()
                }
            }
        }

        dependsOn configTomcat
    }

    task runApp(type: Exec) {
        println "MCR home $mcrHome";
        println "Tomcat server path $tomcatServerPath";
        workingDir Paths.get(confDir, "tomcat")
        commandLine './runTomcat', mcrHome, tomcatServerPath
    }

    task stopApp(type: Exec) {
        println "MCR home $mcrHome";
        println "Tomcat server path $tomcatServerPath";
        workingDir tomcatServerPath.resolve("bin")
        commandLine './shutdown.sh'
    }

    runApp.finalizedBy stopApp

    task runH2DB(type: Exec) {
        workingDir Paths.get(projectDir.getAbsolutePath(), "h2db")
        ignoreExitValue true
        commandLine './runH2DB'
        args configurations.h2db.asPath
        args Paths.get(appPath, "h2db").toString()
        args Paths.get(project.buildDir.getAbsolutePath(), "tmp/h2db.out").toString()
    }

    task stopH2DB(type: Exec) {
        workingDir Paths.get(projectDir.getAbsolutePath(), "h2db")
        ignoreExitValue true
        commandLine './stopH2DB'
        args configurations.h2db.asPath
        args Paths.get(project.buildDir.getAbsolutePath(), "tmp/h2db.out").toString()
    }

    task runSolr(type: Exec) {
        println "Solr home " + appPath + '/solr-home';
        println "Solr server path " + solrServerPath;
        workingDir solrServerPath.toAbsolutePath().toString()
        ignoreExitValue true
        commandLine './bin/solr', 'restart', '-noprompt'
        args '-s', appPath + '/solr-home'
        args '-p', solrPort
    }

    task stopSolr(type: Exec) {
        workingDir solrServerPath.toAbsolutePath().toString()
        ignoreExitValue true
        commandLine './bin/solr', 'stop'
    }

    task runSystem {
        println "Run system using mcr path " + mcrHome;
        dependsOn configApp
        dependsOn runH2DB
        dependsOn runSolr
    }

    task stopSystem {
        dependsOn stopSolr
        dependsOn stopH2DB
    }

    task execute(type:JavaExec) {
        if(project.hasProperty('mainClass')) {
            main = project.getProperty("mainClass")
            classpath = sourceSets.main.runtimeClasspath
        }
    }

}

configurations.all {
    resolutionStrategy {
        cacheDynamicVersionsFor 0, 'seconds'
        cacheChangingModulesFor 0, 'seconds'
    }
}

wrapper {
    gradleVersion = '6.2.1'
}