build.gradle

import ch.digitalfondue.jfiveparse.HtmlSerializer
import ch.digitalfondue.jfiveparse.NodeMatcher
import ch.digitalfondue.jfiveparse.Parser
import ch.digitalfondue.jfiveparse.Selector
import ch.digitalfondue.mjml4j.Mjml4j
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.5.1'
        // for processing the index.html at build time
        classpath "ch.digitalfondue.jfiveparse:jfiveparse:1.1.1"
        // for processing the mjml templates at build time
        classpath "ch.digitalfondue.mjml4j:mjml4j:1.1.1"
    }


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

plugins {
    id 'io.freefair.lombok' version '8.10.2'
    id 'java'
    id 'idea'
    id 'org.kordamp.gradle.jacoco' version '0.54.0'
    id 'com.github.ben-manes.versions' version '0.51.0'
    id 'com.github.hierynomus.license' version '0.16.1'
    id 'net.researchgate.release' version '3.0.2'
    id 'org.springframework.boot' version '3.3.5'
    id 'io.spring.dependency-management' version '1.1.6'
    id 'org.sonarqube' version '5.1.0.4882'
    // id 'net.ltgt.errorprone' version '3.1.0'
    id 'com.github.node-gradle.node' version '7.0.2'
}

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

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

//as pointed out by @facundofarias, we should validate minimum javac version
tasks.register('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 {
    mavenCentral()
    mavenLocal()
    maven { url 'https://repo.spring.io/milestone' }
}

dependencies {
    implementation 'com.auth0:java-jwt:4.4.0'
    implementation "com.fasterxml.jackson.datatype:jackson-datatype-jsr310"
    implementation "com.fasterxml.jackson.dataformat:jackson-dataformat-csv"
    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.16"
    implementation 'com.moodysalem:LatLongToTimezoneMaven:1.2'
    /**/
    implementation 'io.github.openhtmltopdf:openhtmltopdf-core:1.1.22'
    implementation 'io.github.openhtmltopdf:openhtmltopdf-pdfbox:1.1.22'
    implementation 'ch.digitalfondue.jfiveparse:jfiveparse:1.1.1'
    /**/
    implementation 'com.google.zxing:core:3.5.3'
    implementation 'com.google.zxing:javase:3.5.3'
    implementation 'org.flywaydb:flyway-core'
    implementation 'org.flywaydb:flyway-database-postgresql'
    implementation "org.postgresql:postgresql"
    implementation "com.zaxxer:HikariCP"

    /**/

    implementation "com.stripe:stripe-java:25.5.0"
    implementation 'com.paypal.sdk:checkout-sdk:2.0.0'
    implementation 'com.google.code.gson:gson:2.11.0'
    implementation 'com.fatboyindustrial.gson-javatime-serialisers:gson-javatime-serialisers:1.1.2', {
        exclude module: 'gson'
    }

    implementation 'org.apache.commons:commons-lang3:3.17.0'
    implementation 'org.apache.commons:commons-text:1.12.0'
    implementation 'org.apache.commons:commons-collections4:4.4'
    implementation 'commons-codec:commons-codec:1.17.1'
    implementation 'net.sf.biweekly:biweekly:0.6.8'
    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', {
        exclude group: 'org.bouncycastle', module: 'bcprov-jdk15on'
        exclude group: 'org.bouncycastle', module: 'bcmail-jdk15on'
    }
    implementation 'org.bouncycastle:bcprov-jdk15on:1.70'
    implementation 'org.bouncycastle:bcmail-jdk15on:1.70'
    implementation 'com.github.ben-manes.caffeine:caffeine'
    implementation 'com.github.scribejava:scribejava-core:8.3.3'
    implementation 'ch.digitalfondue.vatchecker:vatchecker:1.6.0'
    implementation 'ch.digitalfondue.basicxlsx:basicxlsx:0.7.1'
    implementation 'org.imgscalr:imgscalr-lib:4.2'
    implementation 'org.mozilla:rhino-runtime:1.7.15'
    implementation 'com.google.auth:google-auth-library-oauth2-http:1.29.0'

    testImplementation 'org.testcontainers:testcontainers'
    testImplementation 'org.testcontainers:postgresql'
    testImplementation 'org.testcontainers:junit-jupiter'
    testImplementation "org.springframework.boot:spring-boot-starter-test", {
        exclude module : 'spring-boot-starter-logging'
    }
    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.security:spring-security-oauth2-client"
    implementation "org.springframework.security:spring-security-oauth2-jose"

    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.mockito:mockito-inline:4.5.1"

    testImplementation "org.springdoc:springdoc-openapi-starter-webmvc-ui:2.5.0"
    testImplementation "org.openapitools.openapidiff:openapi-diff-core:2.1.0-beta.10", {
        exclude group: "io.swagger.core.v3", module: "swagger-core"
    }

    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.5"

    testImplementation 'org.mock-server:mockserver-netty-no-dependencies:5.15.0'
    annotationProcessor "org.springframework.boot:spring-boot-configuration-processor"

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

    //errorprone('com.google.errorprone:error_prone_core:2.24.0')
}

sourceSets {
    main {
        resources {
            srcDirs "src/main/webapp"
        }
    }
}

// -- 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')
        property 'sonar.gradle.skipCompile', 'true'
    }
}


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

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 = ['-parameters','-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
tasks.withType(Test).configureEach {
    useJUnitPlatform()
    systemProperties = System.properties
    systemProperties.remove("java.endorsed.dirs")
    testLogging {
        events "failed"
        exceptionFormat "full"
        info.events = ["failed"]
    }
    reports {
        junitXml.required = true  // Enable JUnit XML report
        html.required = true      // Enable HTML report (optional)
    }
}

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)}"
    ]
    if(externalConfig.exists()) {
        opts += externalConfig.readLines()
    }
    jvmArgs = opts
    dependsOn 'copyFrontendDev'
    classpath(layout.buildDirectory.dir('index-transformed'), layout.buildDirectory.dir('frontend-dev'))
}

tasks.register('copyFrontendDev', Copy) {
    dependsOn 'publicFrontendIndexTransform'
    from 'frontend/dist/'
    into layout.buildDirectory.dir("frontend-dev/resources/")
}

// -- code-coverage

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.required = true
        html.required = true
        csv.required = true
    }
}

tasks.register('dockerize', Copy) {
    from 'src/main/dist/Dockerfile'
    into layout.buildDirectory.dir("dockerize")
    filter(ReplaceTokens, tokens: [ALFIO_VERSION: project.version])
}

tasks.register('frontendNpmInstall', NpmTask) {
    args = ['--prefix', "${project.projectDir}/frontend", 'ci']
}

tasks.register('frontendBuild', NpmTask) {
    dependsOn frontendNpmInstall
    args = ['--prefix', "${project.projectDir}/frontend", 'run', 'build']
    outputs.dir("${project.projectDir}/frontend/dist")
}

tasks.register('frontendAdminNpmInstall', NpmTask) {
    args = ['--prefix', "${project.projectDir}/frontend/admin", 'ci']
}

tasks.register('frontendAdminBuild', NpmTask) {
    dependsOn frontendAdminNpmInstall
    args = ['--prefix', "${project.projectDir}/frontend/admin", 'run', 'build']
    outputs.dir("${project.projectDir}/frontend/admin/dist")
}

clean.doFirst {
    delete "${project.projectDir}/frontend/dist"
    delete "${project.projectDir}/frontend/admin/dist"
}

tasks.register('publicFrontendIndexTransform', FrontendIndexTransformTask) {
    dependsOn frontendBuild
    basePath.set("frontend-public/")
    indexHtml.set(layout.projectDirectory.file("frontend/dist/alfio-public-frontend/index.html"))
    indexHtmlTransformed.set(layout.buildDirectory.file("index-transformed/alfio-public-frontend-index.html"))
}

//tasks.register('adminFrontendIndexTransform', FrontendIndexTransformTask) {
//    dependsOn frontendBuild
//    basePath.set("frontend-admin/")
//    indexHtml.set(layout.projectDirectory.file("frontend/dist/alfio-admin-frontend/index.html"))
//    indexHtmlTransformed.set(layout.buildDirectory.file("index-transformed/alfio-admin-frontend-index.html"))
//}

tasks.register('distribution', Copy) {
    from project.layout.buildDirectory.file("libs/alfio-${project.version}-boot.jar")
    rename(new Transformer<String, String>() {
        @Override
        String transform(String s) {
            return "alfio-boot.jar"
        }
    })
    into layout.buildDirectory.dir("dockerize")
    dependsOn publicFrontendIndexTransform, build, dockerize
}

tasks.register('clever', Copy) {
    from project.layout.buildDirectory.file("libs/alfio-${project.version}-boot.jar")
    rename(new Transformer<String, String>() {
        @Override
        String transform(String s) {
            return "alfio-boot.jar"
        }
    })
    into project.layout.buildDirectory.dir("clevercloud")
    dependsOn publicFrontendIndexTransform/*, adminFrontendIndexTransform*/, build
}

release {
    buildTasks = ['distribution']
    git {
        requireBranch.set('')
        pushToRemote.set('origin')
        signTag.set(true)
    }
}

bootJar {
    dependsOn publicFrontendIndexTransform//, adminFrontendIndexTransform
    archiveClassifier.set('boot')
    from(tasks.named("frontendBuild")) {
        into 'BOOT-INF/classes/resources/'
    }
    from(tasks.named("frontendAdminBuild")) {
        into 'BOOT-INF/classes/resources/alfio-admin-frontend/'
    }
    from(tasks.named("publicFrontendIndexTransform")) {
        rename 'alfio-public-frontend-index.html', 'BOOT-INF/classes/alfio-public-frontend-index.html'
    }
    /*from(tasks.named("adminFrontendIndexTransform")) {
        rename 'alfio-admin-frontend-index.html', 'BOOT-INF/classes/alfio-admin-frontend-index.html'
    }*/
    def bowerDir = "resources/bower_components"
    def excludesFile = new File("./lib_exclude")
    if(excludesFile.exists()) {
        exclude(excludesFile.readLines().collect({ bowerDir + it }))
    }
}

// MJML email templates translations to HTML

tasks.register('mjml4jToHtml', Mjml4jTransformTask) {
    files = fileTree("${layout.projectDirectory}/src/main/resources/alfio/mjml/").matching {
        include "**/*.mjml"
        include { !it.isDirectory }
    }
    var d = layout.buildDirectory.dir("generated/resources/alfio/templates/").get();
    d.asFile.mkdirs()
    outputDir = d
}

// 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(mjml4jToHtml)
sourceSets.main.output.dir layout.buildDirectory.dir("generated/resources/"), builtBy: mjml4jToHtml

// transform index.html
abstract class FrontendIndexTransformTask extends DefaultTask {

    @InputFile
    abstract RegularFileProperty getIndexHtml()

    @OutputFile
    abstract RegularFileProperty getIndexHtmlTransformed()

    @Input
    abstract Property<String> getBasePath()

    FrontendIndexTransformTask() {
        basePath.convention("frontend-public/")
    }


    @TaskAction
    def doWork() {
        final resource = indexHtml.get().asFile.newInputStream()
        final indexDoc = new Parser().parse(new InputStreamReader(resource, StandardCharsets.UTF_8))

        NodeMatcher scriptNodes = Selector.select().element("script").toMatcher()

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

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

        indexHtmlTransformed.get().asFile.write(HtmlSerializer.serialize(indexDoc), "UTF-8", false)
    }
}

abstract class Mjml4jTransformTask extends DefaultTask {

    @InputFiles
    FileTree files

    @OutputDirectory
    Directory outputDir

    @TaskAction
    def doWork() {
        files.visit { FileVisitDetails f ->
            var templateOutput = Mjml4j.render(f.file.getText("UTF-8"))
            var outputName = f.file.name.substring(0, f.file.name.lastIndexOf('.')) + ".ms"
            new File(outputDir.asFile, outputName).setText(templateOutput, "UTF-8")
        }
    }
}