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.5.1'
        //this is for processing the index.html at compile time
        classpath "ch.digitalfondue.jfiveparse:jfiveparse:1.0.0"
        //
    }

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

plugins {
    id 'io.freefair.lombok' version '6.6.1'
    id 'java'
    id 'idea'
    id 'org.kordamp.gradle.jacoco' version '0.48.0'
    id 'com.github.ben-manes.versions' version '0.44.0'
    id 'com.github.hierynomus.license' version '0.16.1'
    id 'net.researchgate.release' version '3.0.2'
    id 'org.springframework.boot' version '2.7.7'
    id 'org.sonarqube' version '3.5.0.2730'
    id 'net.ltgt.errorprone' version '2.0.2'
	id 'com.github.node-gradle.node' version '3.5.1'
}

apply plugin: 'java'
apply plugin: 'war'
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 {
    mavenLocal()
    mavenCentral()
}

dependencies {
    implementation "com.fasterxml.jackson.datatype:jackson-datatype-jsr310"
    implementation 'com.auth0:java-jwt:4.2.1'
    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:1.0.0'
    /**/
    implementation 'com.google.zxing:core:3.5.1'
    implementation 'com.google.zxing:javase:3.5.1'
    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.19.0'
    implementation 'org.apache.logging.log4j:log4j-core:2.19.0'
    implementation 'org.apache.logging.log4j:log4j-jul:2.19.0'
    implementation 'org.apache.logging.log4j:log4j-slf4j-impl:2.19.0'
    /**/

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

    implementation "org.apache.commons:commons-lang3:3.12.0"
    implementation 'com.opencsv:opencsv:5.7.1'
    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.3'
    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.google.auth:google-auth-library-oauth2-http:1.3.0'

    compileOnly "javax.servlet:javax.servlet-api:4.0.1"
    testImplementation "javax.servlet:javax.servlet-api:4.0.1"
    testImplementation 'org.testcontainers:testcontainers:1.17.6'
    testImplementation 'org.testcontainers:postgresql:1.17.6'
    testImplementation 'org.testcontainers:junit-jupiter:1.17.6'
    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.mockito:mockito-inline:4.5.1"

    testImplementation "org.springdoc:springdoc-openapi-ui:1.6.14"
    testImplementation "org.openapitools.openapidiff:openapi-diff-core: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.3"

    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.7.2'

    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)
        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 = ['-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)}"
    ]
    if(externalConfig.exists()) {
        opts += externalConfig.readLines()
    }
    jvmArgs = opts
}

// -- 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.enabled = true
        csv.enabled = false
        html.enabled = true
    }
}

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

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

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

clean.doFirst {
    delete "${project.projectDir}/frontend/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 zipTree("${project.buildDir}/libs/alfio-${project.version}-boot.war")
    into "${buildDir}/dockerize"
    dependsOn publicFrontendIndexTransform, build, dockerize
}

tasks.register('clever', 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 publicFrontendIndexTransform, adminFrontendIndexTransform, build
}

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

bootWar {
    dependsOn publicFrontendIndexTransform, adminFrontendIndexTransform
    archiveClassifier.set('boot')
    from(tasks.named("frontendBuild")) {
        into 'resources'
    }
    from(tasks.named("publicFrontendIndexTransform")) {
        rename 'alfio-public-frontend-index.html', 'WEB-INF/classes/alfio-public-frontend-index.html'
    }
    from(tasks.named("adminFrontendIndexTransform")) {
        rename 'alfio-admin-frontend-index.html', 'WEB-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('mjmlToHtml', 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

// transform index.html
abstract class FrontendIndexTransformTask extends org.gradle.api.DefaultTask {

    @org.gradle.api.tasks.InputFile
    abstract org.gradle.api.file.RegularFileProperty getIndexHtml()

    @org.gradle.api.tasks.OutputFile
    abstract org.gradle.api.file.RegularFileProperty getIndexHtmlTransformed()

    @org.gradle.api.tasks.Input
    abstract Property<String> getBasePath()

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


    @org.gradle.api.tasks.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)
    }
}