build.gradle

import com.opentable.db.postgres.embedded.EmbeddedPostgres
import com.opentable.db.postgres.embedded.PgBinaryResolver
import org.apache.commons.io.FileUtils
import org.apache.commons.io.IOUtils
import org.apache.commons.lang3.SystemUtils
import org.apache.tools.ant.filters.ReplaceTokens
import org.springframework.jdbc.core.JdbcTemplate

import java.nio.file.Files
import java.nio.file.Paths
import java.time.Year
import java.time.ZoneId
import java.time.ZonedDateTime
import java.time.format.DateTimeFormatter

import static java.lang.String.format

buildscript {

    dependencies {
        classpath 'com.opentable.components:otj-pg-embedded:0.13.1'
        classpath 'org.postgresql:postgresql:42.2.5'
        classpath "org.springframework:spring-jdbc:$springVersion"
    }

    repositories {
        jcenter()
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
}

plugins {
    id 'io.franzbecker.gradle-lombok' version '1.14'
    id 'java'
    id 'idea'
    id 'jacoco'
    id 'com.github.kt3k.coveralls' version '2.8.2'
    id 'com.github.ben-manes.versions' version '0.21.0'
    id 'com.github.hierynomus.license' version '0.15.0'
    id 'net.researchgate.release' version '2.7.0'
    id 'org.springframework.boot' version '2.1.4.RELEASE'
}

apply plugin: 'java'
apply plugin: 'war'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'


//as pointed out by @facundofarias, we should validate minimum javac version
task validate {
    //check JDK version
    def javaVersion = JavaVersion.current()
    if (!javaVersion.isJava11Compatible()) {
        throw new GradleException("A Java JDK 11+ is required to build the project.")
    }
}

def profile = project.hasProperty('profile') ? project.profile : 'dev'

ext {
    // default settings
    jettyPort = 8080
    jettyHost = '0.0.0.0'
    datasourceUrl = 'jdbc:postgresql://localhost:5432/alfio'
    datasourceUsername = 'postgres'
    datasourcePassword = 'password'
    datasourceValidationQuery = 'SELECT 1'
    //springProfilesActive = 'dev
    //springProfilesActive = 'dev,demo'
    springProfilesActive = 'dev'
    port = "8080"


    switch (profile) {
        case 'docker-test':
            datasourceUrl = 'jdbc:postgresql://0.0.0.0:5432/postgres'
            datasourceUsername = 'postgres'
            datasourcePassword = 'postgres'
            datasourceValidationQuery = 'SELECT 1'
            break
        case 'travis':
            project.springProfilesActive = 'travis'
            break
    }
}

configurations {
    compileOnly
    testCompileOnly
    providedRuntime
    providedCompile
}

repositories {
    mavenLocal()
    mavenCentral()
    jcenter()
}

dependencies {
    compile "org.springframework:spring-webmvc:$springVersion"
    compile "org.springframework:spring-context-support:$springVersion"
    compile "org.springframework:spring-jdbc:$springVersion"
    compile "org.springframework:spring-aop:$springVersion"
    compile "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:$jacksonVersion"
    compile "com.fasterxml.jackson.core:jackson-core:$jacksonVersion"
    compile "com.fasterxml.jackson.core:jackson-databind:$jacksonVersion"
    compile "org.springframework.boot:spring-boot-properties-migrator", {
        exclude module : 'spring-boot-starter-logging'
    }
    compile "org.springframework.security:spring-security-web:$springSecurityConfigVersion"
    compile "org.springframework.security:spring-security-config:$springSecurityConfigVersion"
    compile 'org.springframework.session:spring-session:1.3.5.RELEASE'
    compile "ch.digitalfondue.npjt-extra:npjt-extra:1.1.5"
    compile "com.samskivert:jmustache:1.14"
    compile "com.github.sps.mustache:mustache-spring-view:1.4"
    compile "javax.mail:mail:1.5.0-b01"
    compile 'com.moodysalem:LatLongToTimezoneMaven:1.2'
    /**/
    compile "com.openhtmltopdf:openhtmltopdf-core:0.0.1-RC20"
    compile "com.openhtmltopdf:openhtmltopdf-pdfbox:0.0.1-RC20"
    compile "ch.digitalfondue.jfiveparse:jfiveparse:0.5.3"
    /**/
    compile "com.google.zxing:core:3.3.3"
    compile "com.google.zxing:javase:3.3.3"
    compile "org.flywaydb:flyway-core:5.1.3"
    compile "org.postgresql:postgresql:42.2.5"
    compile "com.zaxxer:HikariCP:3.3.1"
    compile "org.apache.logging.log4j:log4j-api:$log4jVersion"
    compile "com.stripe:stripe-java:7.26.0"
    compile 'com.paypal.sdk:rest-api-sdk:1.14.0'
    compile 'com.squareup.okhttp3:okhttp:3.13.1'
    compile "org.apache.commons:commons-lang3:3.8.1"
    compile "org.apache.commons:commons-text:1.6"
    compile "com.opencsv:opencsv:4.4"
    compile 'commons-codec:commons-codec:1.12'
    compile 'net.sf.biweekly:biweekly:0.6.3'
    compile 'com.atlassian.commonmark:commonmark:0.12.1'
    compile 'com.ryantenney.passkit4j:passkit4j:2.0.1'
    compile 'com.github.ben-manes.caffeine:caffeine:2.7.0'
    compile 'de.danielbechler:java-object-diff:0.95'
    compile 'com.github.scribejava:scribejava-core:5.0.0'
    compile 'ch.digitalfondue.vatchecker:vatchecker:1.2'
    compile 'ch.digitalfondue.basicxlsx:basicxlsx:0.5.0'
    compile 'org.imgscalr:imgscalr-lib:4.2'
    compile 'org.aspectj:aspectjweaver:1.9.2'

    testCompile 'com.opentable.components:otj-pg-embedded:0.13.1'

    compileOnly "javax.servlet:javax.servlet-api:4.0.1"
    testCompile "javax.servlet:javax.servlet-api:4.0.1"
    testCompile "org.springframework.boot:spring-boot-starter-test", {
        exclude module : 'spring-boot-starter-logging'
    }
    testCompile "net.sourceforge.htmlunit:htmlunit:2.33"
    runtime "commons-fileupload:commons-fileupload:1.4"
    providedCompile "org.springframework.boot:spring-boot-starter-web", {
        exclude module : 'spring-boot-starter-logging'
        exclude group: "org.springframework.boot", module: 'spring-boot-starter-tomcat'
        exclude group: "org.hibernate.validator"
    }
    providedCompile "org.springframework.boot:spring-boot-starter", {
        exclude module : 'spring-boot-starter-logging'
    }
    providedCompile "org.springframework.boot:spring-boot@jar", {
        exclude module : 'spring-boot-starter-logging'
    }
    providedCompile "org.springframework.boot:spring-boot-autoconfigure@jar", {
        exclude module : 'spring-boot-starter-logging'
    }
    providedCompile "org.springframework.boot:spring-boot-starter-log4j2"
    compile "org.springframework.boot:spring-boot-starter-jetty", {
        exclude group: "org.eclipse.jetty.websocket", module: "websocket-server"
        exclude group: "org.eclipse.jetty.websocket", module:"javax-websocket-server-impl"
    }

    testCompile "org.junit.jupiter:junit-jupiter-api"
    testCompile "org.junit.jupiter:junit-jupiter-engine"
    testCompile "org.junit.platform:junit-platform-engine"
    testRuntime "org.junit.vintage:junit-vintage-engine:$junitVersion"

    providedCompile "org.springframework.boot:spring-boot-starter-jetty", {
        exclude group: "org.eclipse.jetty.websocket", module: "websocket-server"
        exclude group: "org.eclipse.jetty.websocket", module:"javax-websocket-server-impl"
        exclude module : 'spring-boot-starter-logging'
    }
    providedRuntime "org.springframework.boot:spring-boot-starter-jetty", {
        exclude group: "org.eclipse.jetty.websocket", module: "websocket-server"
        exclude group: "org.eclipse.jetty.websocket", module:"javax-websocket-server-impl"
        exclude module : 'spring-boot-starter-logging'
    }
}

// -- license configuration

license {
    header = rootProject.file('config/HEADER')
    strictCheck = true
    ignoreFailures = false
    mapping {
        java = 'JAVADOC_STYLE'
        sql = 'DOUBLEDASHES_STYLE'
    }
    ext.year = '2014-'+Year.now().toString()
    include '**/*.java'
    include '**/*.sql'
}


processResources {

    doLast {

        final gradleProperties = new File((File) it.destinationDir, 'application.properties')
        final properties = new Properties()

        assert gradleProperties.file

        gradleProperties.withReader { properties.load(it) }
        properties['alfio.version'] = project.version
        properties['alfio.build-ts'] = ZonedDateTime.now(ZoneId.of("UTC")).format(DateTimeFormatter.ISO_ZONED_DATE_TIME)
        gradleProperties.withWriter { properties.store(it, null) }
    }
}

compileJava {
    options.compilerArgs = ['-Xlint:all,-serial,-processing']
}

//propagate the system properties to the tests
test {
    useJUnitPlatform()
    systemProperties = System.properties
    systemProperties.remove("java.endorsed.dirs")
    jvmArgs("--illegal-access=warn")
    testLogging {
        events "failed"
        exceptionFormat "full"
        info.events = ["failed"]
    }
}


bootRun {
    def externalConfig = new File("./custom.jvmargs")
    def opts = []
    opts += [
        "-Dspring.profiles.active=${project.springProfilesActive}",
        "-Ddatasource.url=${project.datasourceUrl}",
        "-Ddatasource.username=${project.datasourceUsername}",
        "-Ddatasource.password=${project.datasourcePassword}",
        "-Dalfio.version=${project.version}",
        "-Dalfio.build-ts=${ZonedDateTime.now(ZoneId.of("UTC")).format(DateTimeFormatter.ISO_ZONED_DATE_TIME)}"
    ]
    if(externalConfig.exists()) {
        opts += externalConfig.readLines()
    }
    jvmArgs = opts
}

bootWar {
    mainClassName = 'alfio.config.SpringBootLauncher'
    classifier = 'boot'

    def bowerDir = "resources/bower_components"
    def excludesFile = new File("./lib_exclude")
    if(excludesFile.exists()) {
        exclude(excludesFile.readLines().collect({ bowerDir + it }))
    }
}

// -- code-coverage

jacoco {
    toolVersion = '0.8.2'
}

jacocoTestReport {
    group = 'Reporting'
    description = 'Generate Jacoco coverage reports after running tests.'
    additionalSourceDirs.from(project.files(sourceSets.main.allSource.srcDirs))
    sourceDirectories.from(project.files(sourceSets.main.allSource.srcDirs))
    classDirectories.from(project.files(sourceSets.main.output))
    reports {
        xml.enabled = true
        csv.enabled = false
        html.enabled = true
    }
}

task dockerize(type: Copy) {
    from 'src/main/dist/Dockerfile'
    into "${buildDir}/dockerize"
    filter(ReplaceTokens, tokens: [ALFIO_VERSION: project.version])
}

task distribution(type: Copy) {
    from zipTree("${project.buildDir}/libs/alfio-${project.version}-boot.war")
    into "${buildDir}/dockerize"
    dependsOn build, dockerize
}

task clever(type: Copy) {
    from new File(project.buildDir, "libs/alfio-${project.version}-boot.war")
    rename(new Transformer<String, String>() {
        @Override
        String transform(String s) {
            return "alfio-boot.war"
        }
    })
    into "${project.buildDir}/clevercloud"
    dependsOn build
}

task startEmbeddedPgSQL {
    doLast {
        def pgsqlPath = Paths.get(System.getProperty("user.dir"), "alfio-itest")
        Files.createDirectories(pgsqlPath)
        def tmpDataDir = Files.createTempDirectory(pgsqlPath, "alfio-data")

        def binDir = "alfio-pg-bin"+(UUID.randomUUID().toString())
        def postgresBinariesDir = Files.createDirectories(pgsqlPath.resolve(binDir)).toAbsolutePath().toFile()

        def postgres = EmbeddedPostgres.builder()
            .setPort(5432)
            .setDataDirectory(tmpDataDir)
            .setOverrideWorkingDirectory(postgresBinariesDir)
            // we are doing this because there is an unfortunate interplay with the persistence of the gradle daemon and
            // EmbeddedPostgres.PREPARE_BINARIES (which is a static field)
            // this cause to reuse a wrong directory
            .setPgBinaryResolver(new PgBinaryResolver() {
                @Override
                InputStream getPgBinary(String system, String machineHardware) {
                    return EmbeddedPostgres.class.getResourceAsStream(format("/postgresql-%s-%s.txz", system, machineHardware));
                }
            })
            .start()

        // create a new admin, and then rename the user "postgres" as we don't want to have the superuser roles
        def jdbc = new JdbcTemplate(postgres.getDatabase("postgres", "postgres"))
        jdbc.execute("CREATE ROLE tmpadmin LOGIN PASSWORD 'password' SUPERUSER")

        jdbc = new JdbcTemplate(postgres.getDatabase("tmpadmin", "postgres"))
        jdbc.execute("ALTER USER postgres RENAME TO admin")
        //
        //todo: check if the following grants are necessary
        jdbc.execute("CREATE ROLE postgres LOGIN PASSWORD 'password' NOSUPERUSER INHERIT CREATEDB CREATEROLE REPLICATION")
        jdbc.execute("GRANT pg_monitor TO postgres")
        jdbc.execute("GRANT pg_read_all_settings TO postgres")
        jdbc.execute("GRANT pg_read_all_stats TO postgres")
        jdbc.execute("GRANT pg_signal_backend TO postgres")
        jdbc.execute("GRANT pg_stat_scan_tables TO postgres")
        jdbc.execute("CREATE DATABASE alfio WITH OWNER postgres")
        //
        Files.write(Paths.get(".", "alfio-itest", "pgsql-descriptor"), Arrays.asList(tmpDataDir.toAbsolutePath().toFile().toString(), postgresBinariesDir.toString()))
        System.out.println("Launched pgsql")
    }
}

// code imported from EmbeddedPostgres :D
String pgBin(File pgDirBase, String binaryName) {
    final pgDir = pgDirBase.listFiles(new FileFilter() {
        @Override
        boolean accept(File file) {
            return file.getName().startsWith("PG-") && file.isDirectory()
        }
    })[0]
    final String extension = SystemUtils.IS_OS_WINDOWS ? ".exe" : ""
    return new File(pgDir, "bin/" + binaryName + extension).getPath()
}

void system(String... command) {
    final ProcessBuilder builder = new ProcessBuilder(command)
    final Process process = builder.start()
    if (0 != process.waitFor()) {
        throw new IllegalStateException(String.format("Process %s failed%n%s", Arrays.asList(command), IOUtils.toString(process.getErrorStream())))
    }
}

void pgCtl(File binDir, File dataDir, String action) {
    system(pgBin(binDir, "pg_ctl"), "-D", dataDir.getPath(), action, "-m", "fast", "-t", "5", "-w")
}
//

task stopEmbeddedPgSQL {
    doLast {
        def descriptor = Paths.get(".", "alfio-itest", "pgsql-descriptor")
        def r = Files.readAllLines(descriptor)
        def dataDir = new File(r.get(0))
        def binariesDir = new File(r.get(1))

        pgCtl(binariesDir, dataDir, "stop")
        Files.deleteIfExists(descriptor)
        FileUtils.deleteDirectory(dataDir)
        FileUtils.deleteDirectory(binariesDir)
        System.out.println("Stopped postgresql")
    }
}

release {
    buildTasks = ['distribution']
    git {
        requireBranch = ''
        pushToRemote = 'origin'
        signTag = true
    }
}

lombok {
    version = '1.18.4'
    sha256 = ""
}