build.gradle

import ch.digitalfondue.jfiveparse.HtmlSerializer
import ch.digitalfondue.jfiveparse.NodeMatcher
import ch.digitalfondue.jfiveparse.Parser
import ch.digitalfondue.jfiveparse.Selector
import org.apache.tools.ant.filters.ReplaceTokens

import java.nio.charset.StandardCharsets
import java.time.Year
import java.time.ZoneId
import java.time.ZonedDateTime
import java.time.format.DateTimeFormatter

buildscript {

    dependencies {
        classpath 'org.postgresql:postgresql:42.2.20'
        //this is for processing the index.html at compile time
        classpath "com.github.alfio-event:alf.io-public-frontend:$alfioPublicFrontendVersion"
        classpath "ch.digitalfondue.jfiveparse:jfiveparse:0.9.0"
        //
    }

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

plugins {
    id 'io.freefair.lombok' version '6.3.0'
    id 'java'
    id 'idea'
    id 'org.kordamp.gradle.jacoco' version '0.47.0'
    id 'com.github.ben-manes.versions' version '0.41.0'
    id 'com.github.hierynomus.license' version '0.16.1'
    id 'net.researchgate.release' version '2.8.1'
    id 'org.springframework.boot' version '2.6.6'
    id 'org.sonarqube' version '3.3'
    id 'net.ltgt.errorprone' version '2.0.2'
	id 'com.github.node-gradle.node' version '3.1.1'
}

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


//as pointed out by @facundofarias, we should validate minimum javac version
task validate {
    //check JDK version
    def javaVersion = JavaVersion.current()
    if (!javaVersion.isCompatibleWith(JavaVersion.VERSION_17)) {
        throw new GradleException("A Java JDK 17+ 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()
    maven {
        url "https://jitpack.io"
    }
}

dependencies {
    implementation "com.fasterxml.jackson.datatype:jackson-datatype-jsr310"
    implementation 'com.auth0:java-jwt:3.19.2'
    implementation "com.fasterxml.jackson.core:jackson-core"
    implementation "com.fasterxml.jackson.core:jackson-databind"
    implementation "org.springframework.boot:spring-boot-properties-migrator", {
        exclude module : 'spring-boot-starter-logging'
    }
    implementation 'org.springframework.session:spring-session-jdbc'
    implementation "ch.digitalfondue.npjt-extra:npjt-extra:2.0.4"
    implementation "com.samskivert:jmustache:1.15"
    implementation "javax.mail:mail:1.5.0-b01"
    implementation 'com.moodysalem:LatLongToTimezoneMaven:1.2'
    /**/
    implementation 'com.openhtmltopdf:openhtmltopdf-core:1.0.10'
    implementation 'com.openhtmltopdf:openhtmltopdf-pdfbox:1.0.10'
    implementation "ch.digitalfondue.jfiveparse:jfiveparse:0.9.0"
    /**/
    implementation 'com.google.zxing:core:3.5.0'
    implementation 'com.google.zxing:javase:3.5.0'
    implementation "org.flywaydb:flyway-core"
    implementation "org.postgresql:postgresql"
    implementation "com.zaxxer:HikariCP"

    /* https://www.lunasec.io/docs/blog/log4j-zero-day/ */
    implementation 'org.apache.logging.log4j:log4j-api:2.17.2'
    implementation 'org.apache.logging.log4j:log4j-core:2.17.2'
    implementation 'org.apache.logging.log4j:log4j-jul:2.17.2'
    implementation 'org.apache.logging.log4j:log4j-slf4j-impl:2.17.2'
    /**/

    implementation 'com.stripe:stripe-java:20.120.0'
    implementation 'com.paypal.sdk:checkout-sdk:1.0.5'
    implementation 'com.google.code.gson:gson:2.9.0'
    implementation 'com.fatboyindustrial.gson-javatime-serialisers:gson-javatime-serialisers:1.1.1', {
        exclude module: 'gson'
    }

    implementation "org.apache.commons:commons-lang3:3.12.0"
    implementation "org.apache.commons:commons-text:1.9"
    implementation 'com.opencsv:opencsv:5.6'
    implementation 'commons-codec:commons-codec:1.15'
    implementation 'net.sf.biweekly:biweekly:0.6.6'
    implementation 'com.atlassian.commonmark:commonmark:0.17.0'
    implementation 'com.atlassian.commonmark:commonmark-ext-gfm-tables:0.17.0'
    implementation 'com.ryantenney.passkit4j:passkit4j:2.0.1'
    implementation 'com.github.ben-manes.caffeine:caffeine'
    implementation 'com.github.scribejava:scribejava-core:8.3.1'
    implementation 'ch.digitalfondue.vatchecker:vatchecker:1.5.0'
    implementation 'ch.digitalfondue.basicxlsx:basicxlsx:0.5.1'
    implementation 'org.imgscalr:imgscalr-lib:4.2'
    implementation 'org.mozilla:rhino-runtime:1.7.13'

    implementation "com.github.alfio-event:alf.io-public-frontend:$alfioPublicFrontendVersion"

    compileOnly "javax.servlet:javax.servlet-api:4.0.1"
    testImplementation "javax.servlet:javax.servlet-api:4.0.1"
    testImplementation 'org.testcontainers:testcontainers:1.17.1'
    testImplementation 'org.testcontainers:postgresql:1.17.1'
    testImplementation 'org.testcontainers:junit-jupiter:1.17.1'
    testImplementation "org.springframework.boot:spring-boot-starter-test", {
        exclude module : 'spring-boot-starter-logging'
    }
    runtimeOnly "commons-fileupload:commons-fileupload:1.4"
    implementation "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"
    }
    implementation "org.springframework.boot:spring-boot-starter-security", {
        exclude module : 'spring-boot-starter-logging'
    }

    implementation "org.springframework.boot:spring-boot-starter-mail", {
        exclude module : 'spring-boot-starter-logging'
    }

    implementation "org.springframework.boot:spring-boot@jar", {
        exclude module : 'spring-boot-starter-logging'
    }
    implementation "org.springframework.boot:spring-boot-autoconfigure@jar", {
        exclude module : 'spring-boot-starter-logging'
    }
    implementation "org.springframework.boot:spring-boot-starter-log4j2"
    implementation "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"
    }

    testImplementation "org.junit.jupiter:junit-jupiter-api"
    testImplementation "org.junit.jupiter:junit-jupiter-engine"
    testImplementation "org.junit.platform:junit-platform-engine"

    testImplementation "org.springdoc:springdoc-openapi-ui:1.6.9"
    testImplementation "org.glassfish:jakarta.json:2.0.1"

    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'
    }

    implementation "org.joda:joda-money:1.0.1"

    testImplementation 'org.mock-server:mockserver-netty:5.13.2', {
        exclude group: 'org.mozilla', module: 'rhino'
    }
    annotationProcessor "org.springframework.boot:spring-boot-configuration-processor"

    testImplementation 'org.seleniumhq.selenium:selenium-java:4.1.4'

    errorprone('com.google.errorprone:error_prone_core:2.10.0')
}

// -- 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'
}

sonarqube {
    properties {
        property 'sonar.host.url', 'https://sonarcloud.io'
        property 'sonar.organization', 'alfio-event'
        property 'sonar.projectKey', 'alfio-event_alf.io'
        property 'sonar.login', System.getenv('SONARCLOUD_TOKEN')
    }
}


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)
        properties['alfio.frontend.version'] = alfioPublicFrontendVersion
        gradleProperties.withWriter { properties.store(it, null) }


        //
        // alf.io public frontend: read index.html rewrite path for css/js

        final resource = Thread.currentThread().getContextClassLoader().getResourceAsStream("META-INF/resources/webjars/alfio-public-frontend/$alfioPublicFrontendVersion/alfio-public-frontend/index.html")
        final indexDoc = new Parser().parse(new InputStreamReader(resource, StandardCharsets.UTF_8))

        final basePath = "webjars/alfio-public-frontend/$alfioPublicFrontendVersion/alfio-public-frontend/"
        NodeMatcher scriptNodes = Selector.select().element("script").toMatcher()

        indexDoc.getAllNodesMatching(scriptNodes).stream().forEach({
            it.setAttribute("src", basePath + it.getAttribute("src"))
        })

        NodeMatcher cssNodes = Selector.select().element("link").attrValEq("rel", "stylesheet").toMatcher();
        indexDoc.getAllNodesMatching(cssNodes).stream().forEach({
            it.setAttribute("href", basePath + it.getAttribute("href"))
        })

        final alfioPublicIndex = new File((File) it.destinationDir, "alfio-public-frontend-index.html")
        alfioPublicIndex.write(HtmlSerializer.serialize(indexDoc), "UTF-8", false)
    }
}

compileTestJava {
    options.errorprone.disable('UnusedVariable',
        'MixedMutabilityReturnType',
        'MissingOverride',
        'ImmutableEnumChecker', // not too useful, as it does not take into account the actual value of the field
        'AlmostJavadoc',
        'MissingSummary',
        'EscapedEntity',
        'EmptyBlockTag',
        'SameNameButDifferent'
    )
}

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

    // both checks are problematic with lombok code
    options.errorprone.disable('UnusedVariable',
        'MixedMutabilityReturnType',
        'MissingOverride',
        'ImmutableEnumChecker', // not too useful, as it does not take into account the actual value of the field
        'AlmostJavadoc',
        'MissingSummary',
        'EscapedEntity',
        'EmptyBlockTag',
        'SameNameButDifferent',
        'ReturnValueIgnored'
    )
}

compileJava.dependsOn(processResources)

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

springBoot {
    mainClass = 'alfio.config.SpringBootLauncher'
}

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)}",
        "-Dalfio.frontend.version=$alfioPublicFrontendVersion"
    ]
    if(externalConfig.exists()) {
        opts += externalConfig.readLines()
    }
    jvmArgs = opts
}

bootWar {
    archiveClassifier.set('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.7'
}

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
}

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

// MJML email templates translations to HTML
node {
    download = true
}

task mjmlToHtml( type: NodeTask, dependsOn: 'npmInstall' ) {
    script = file( 'src/main/node/mjmlToHtml.js' )
}
// We build HTML templates from MJML source files and then save them under "build/generated/resources" in order to be
// included in the final artifact.
// TODO should we do the same for plaintext templates? See https://gist.github.com/brasilikum/3cd515bad5541ca6c76873faf10445c2
processResources.dependsOn(mjmlToHtml)
sourceSets.main.output.dir file("$buildDir/generated/resources"), builtBy: mjmlToHtml