build.gradle

buildscript {
    ext.cubaVersion = '7.2.0'
    repositories {

        mavenLocal()
        maven {
            url 'https://repo.cuba-platform.com/content/groups/work'
            credentials {
                username(rootProject.hasProperty('repoUser') ? rootProject['repoUser'] : 'cuba')
                password(rootProject.hasProperty('repoPass') ? rootProject['repoPass'] : 'cuba123')
            }
        }

    }
    dependencies {
        classpath "com.haulmont.gradle:cuba-plugin:$cubaVersion"

        classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.0"

        classpath 'net.saliman:gradle-cobertura-plugin:2.5.0'
        classpath "org.kt3k.gradle.plugin:coveralls-gradle-plugin:2.8.2"
    }
}


plugins {
    id 'net.researchgate.release' version '2.8.0'
}

apply plugin: "com.github.kt3k.coveralls"


def modulePrefix = 'dataimport'

def globalModule = project(":${modulePrefix}-global")
def coreModule = project(":${modulePrefix}-core")
def guiModule = project(":${modulePrefix}-gui")
def webModule = project(":${modulePrefix}-web")

def servletApi = 'javax.servlet:javax.servlet-api:3.1.0'


apply(plugin: 'cuba')


cuba {
    artifact {
        group = 'de.diedavids.cuba.dataimport'
        version = project.properties['version'].replaceAll('-SNAPSHOT', '')
        isSnapshot = project.properties['version'].contains('-SNAPSHOT')
    }
    tomcat {
        dir = "$project.rootDir/deploy/tomcat"
    }
}

subprojects {
    apply plugin: 'com.jfrog.bintray'

    bintray {
        user = System.getenv('BINTRAY_USERNAME')
        key = System.getenv('BINTRAY_PASSWORD')

        configurations = ['archives']

        publish = true

        override = false

        // metadata
        pkg {
            repo = 'cuba-components'
            name = 'cuba-component-data-import'
            desc = 'CUBA platform application component for data import'
            userOrg = 'mariodavid'

            websiteUrl = 'https://github.com/mariodavid/cuba-component-data-import'
            issueTrackerUrl = 'https://github.com/mariodavid/cuba-component-data-import/issues'
            vcsUrl = 'https://github.com/mariodavid/cuba-component-data-import.git'

            licenses = ["Apache-2.0"]

            labels = ['data-import', 'cuba-patform', 'cuba-component']
            githubRepo = 'mariodavid/cuba-component-data-import'
            githubReleaseNotesFile = 'CHANGELOG.md'

            version {
                name = "${cuba.artifact.version}"
                desc = ''
                released = new Date()
                vcsTag = "${cuba.artifact.version}"
            }
        }
    }
}

dependencies {
    appComponent("com.haulmont.cuba:cuba-global:$cubaVersion")
    appComponent('de.balvi.cuba.declarativecontrollers:declarativecontrollers-global:0.10.0')

}

def hsql = 'org.hsqldb:hsqldb:2.4.1'


allprojects {
    apply plugin: 'net.saliman.cobertura'
}


def files = subprojects
        .findAll { !it.name.toLowerCase().contains('theme') }
        .collect { new File(it.projectDir, '/build/cobertura/cobertura.ser') }
def sourceDirs = subprojects
        .findAll { !it.name.toLowerCase().contains('theme') }
        .collect { new File(it.projectDir, '/src') }

cobertura {
    coverageFormats = ['html', 'xml']
    coverageMergeDatafiles = files
    coverageCheckTotalBranchRate = 0
    coverageCheckTotalLineRate = 0
    coverageCheckHaltOnFailure = true
    coverageSourceDirs = sourceDirs
//    coverageCheckLineRate = 1
    coverageCheckRegexes = [[regex: '.*\\$.*', branchRate: 0, lineRate: 0]]

}


test.dependsOn(subprojects.collect { ":${it.name}:test" })
test.finalizedBy(project.tasks.cobertura)
test.finalizedBy(project.tasks.coberturaCheck)


configure([globalModule, coreModule, guiModule, webModule]) {
    apply(plugin: 'java')
    apply(plugin: 'maven')
    apply(plugin: 'cuba')

    dependencies {
        compile('org.codehaus.groovy:groovy-all:2.5.2')
        testCompile 'org.assertj:assertj-core:2.9.0'

        testCompile('org.junit.jupiter:junit-jupiter-api:5.5.2')
        testCompile('org.junit.jupiter:junit-jupiter-engine:5.5.2')
        testCompile('org.junit.vintage:junit-vintage-engine:5.5.2')

        testCompile('org.spockframework:spock-core:1.2-groovy-2.5')
        testCompile('org.springframework:spring-test:4.3.1.RELEASE')
        testRuntime "cglib:cglib-nodep:3.2.4"
    }

    task sourceJar(type: Jar) {
        from file('src')
        classifier = 'sources'
    }

    artifacts {
        archives sourceJar
    }

    test {
        useJUnitPlatform()
    }
}

configure([globalModule, coreModule, guiModule, webModule]) {
    apply(plugin: 'groovy')
    apply plugin: 'net.saliman.cobertura'
    apply plugin: 'codenarc'

    codenarc {
        toolVersion = "1.3"
        ignoreFailures = false
        reportFormat = 'html'
        reportsDir = project.file("build/reports/codenarc")
    }

    codenarcMain {
        configFile = rootProject.file("config/codenarc/rulesMain.groovy")
    }
    codenarcTest {
        configFile = rootProject.file("config/codenarc/rulesTests.groovy")
    }


    cobertura {
        coverageFormats = ['html', 'xml']
        coverageIgnoreTrivial = true
        coverageIgnores = ['org.slf4j.Logger.*']
        coverageReportDir = new File("$buildDir/reports/cobertura")

        coverageExcludes = [
                '.*Enum',
        ]
    }

    test.finalizedBy(project.tasks.cobertura)
    test.finalizedBy(project.tasks.coberturaCheck)

    sourceSets {
        main {
            groovy { srcDirs = ["src"] }
            java.outputDir = new File(project.buildDir, "classes/main")
            groovy.outputDir = new File(project.buildDir, "classes/main")
        }
        test {
            groovy { srcDirs = ["test"] }
            java.outputDir = new File(project.buildDir, "classes/test")
            groovy.outputDir = new File(project.buildDir, "classes/test")
        }
    }
    sourceSets.main.output.classesDirs.setFrom(new File(project.buildDir, "classes/main"))
    sourceSets.test.output.classesDirs.setFrom(new File(project.buildDir, "classes/test"))
}

configure(globalModule) {
    dependencies {
        if (!JavaVersion.current().isJava8()) {
            runtime('javax.xml.bind:jaxb-api:2.3.1')
            runtime('org.glassfish.jaxb:jaxb-runtime:2.3.1')
        }
        compile('org.apache.poi:poi-ooxml:4.1.1')
        compile 'com.xlson.groovycsv:groovycsv:1.3'
    }

    entitiesEnhancing {
        main { enabled = true }
        test {
            enabled = false
            persistenceConfig = 'dataimport-test-persistence.xml'
        }
    }

    jar {
        manifest {
            attributes('App-Component-Id': cuba.artifact.group)
            attributes('App-Component-Version': cuba.artifact.version + (cuba.artifact.isSnapshot ? '-SNAPSHOT' : ''))
        }
    }
}

configure(coreModule) {

    entitiesEnhancing {
        main { enabled = true }
        test {
            enabled = true
            persistenceConfig = 'dataimport-test-persistence.xml'
        }

    }

    configurations {
        jdbc
        dbscripts
    }

    dependencies {
        compile(globalModule)
        compileOnly(servletApi)
        jdbc(hsql)
        testRuntime(hsql)
        compile('org.apache.poi:poi-ooxml:4.1.1')

    }

    task cleanConf(description: 'Cleans up conf directory', type: Delete) {
        delete "$cuba.appHome/${modulePrefix}-core/conf"
    }

    task deploy(dependsOn: [assemble, cleanConf], type: CubaDeployment) {
        appName = "${modulePrefix}-core"
        appJars(modulePrefix + '-global', modulePrefix + '-core')
    }


    def hsqlDbName = 'ddcdi4'
    def hsqlPort = 9001

    task startDb(description: 'Starts local HSQLDB server', type: CubaHsqlStart) {
        dbPort = hsqlPort
        dbName = hsqlDbName
    }

    task stopDb(description: 'Stops local HSQLDB server', type: CubaHsqlStop) {
        dbPort = hsqlPort
        dbName = hsqlDbName
    }

    task removeDb(description: 'Removes local HSQL database', type: Delete) {
        delete new File("$rootProject.projectDir/data")
    }

    task killDb(description: "Kill local HSQLDB server process running on port $hsqlPort", type: CubaKillProcess) {
        port = hsqlPort
    }

    task createDb(dependsOn: assembleDbScripts, description: 'Creates local database', type: CubaDbCreation) {
        dbName = 'ddcdi4'
        dbms = 'hsql'
        host = 'localhost'
        dbUser = 'sa'
        dbPassword = ''
    }

    task updateDb(dependsOn: assembleDbScripts, description: 'Updates local database', type: CubaDbUpdate) {
        dbName = 'ddcdi4'
        dbms = 'hsql'
        host = 'localhost'
        dbUser = 'sa'
        dbPassword = ''
    }


    task createTestDb(dependsOn: assembleDbScripts, description: 'Creates local HSQL database', type: CubaDbCreation) {
        dbms = 'hsql'
        host = "localhost:$hsqlPort"
        dbName = hsqlDbName
        dbUser = 'sa'
        dbPassword = ''
        auxiliaryScript = file('test/de/diedavids/cuba/dataimport/create-db.sql')
    }

    //tasks.test.dependsOn(assembleDbScripts)
}

configure(guiModule) {
    dependencies {
        compile(globalModule)

    }

    task deployConf(type: Copy) {
        from file('src')
        include "de/diedavids/cuba/dataimport/**"
        into "$cuba.appHome/${modulePrefix}/conf"
    }
}

configure(webModule) {
    configurations {
        webcontent
    }

    dependencies {
        compileOnly(servletApi)
        compile(guiModule)

    }

    task webArchive(type: Zip) {
        from file("$buildDir/web")
        from file('web')
        classifier = 'web'
    }

    artifacts {
        archives webArchive
    }

    task deployConf(type: Copy) {
        from file('src')
        include "de/diedavids/cuba/dataimport/**"
        into "$cuba.appHome/${modulePrefix}/conf"
    }

    task clearMessagesCache(type: CubaClearMessagesCache) {
        appName = "${modulePrefix}"
    }
    deployConf.dependsOn clearMessagesCache

    task cleanConf(description: 'Cleans up conf directory', type: Delete) {
        delete "$cuba.appHome/${modulePrefix}/conf"
    }

    task deploy(dependsOn: [assemble, cleanConf], type: CubaDeployment) {
        appName = "${modulePrefix}"
        appJars(modulePrefix + '-global', modulePrefix + '-gui', modulePrefix + '-web')
    }
}


task undeploy(type: Delete, dependsOn: ":${modulePrefix}-web:cleanConf") {
    delete("$cuba.tomcat.dir/shared")
    delete("$cuba.tomcat.dir/webapps/${modulePrefix}-core")
    delete("$cuba.tomcat.dir/webapps/${modulePrefix}")
}

task restart(dependsOn: ['stop', ":${modulePrefix}-core:deploy", ":${modulePrefix}-web:deploy"], description: 'Redeploys applications and restarts local Tomcat') {
    doLast {
        ant.waitfor(maxwait: 6, maxwaitunit: 'second', checkevery: 2, checkeveryunit: 'second') {
            not {
                socket(server: 'localhost', port: '8787')
            }
        }
    }
}
restart.finalizedBy start


clean {
    delete = ['build/libs', 'build/tmp']
}