build.gradle

import org.labkey.gradle.plugin.TeamCity
import org.labkey.gradle.plugin.extension.ServerDeployExtension
import org.labkey.gradle.plugin.extension.TeamCityExtension
import org.labkey.gradle.task.DoThenSetup
import org.labkey.gradle.util.BuildUtils
import org.labkey.gradle.util.GroupNames
import org.labkey.gradle.util.PropertiesUtils
import org.labkey.gradle.util.ExternalDependency

import java.util.regex.Matcher

//repositories {
//    mavenCentral()
//    maven {
//        url "https://maven.scijava.org/content/groups/public/"
//        content {
//            includeGroup "cisd" //jhdf5
//        }
//    }
//}

configurations.all {
    resolutionStrategy {
        force "org.glassfish.jaxb:jaxb-runtime:${jaxbVersion}"
    }
}

dependencies {
    apiImplementation "com.github.samtools:htsjdk:${htsjdkVersion}"
    BuildUtils.addExternalDependency(
            project,
            new ExternalDependency(
                    "com.github.samtools:htsjdk:${htsjdkVersion}",
                    'htsjdk',
                    'htsjdk',
                    'http://samtools.github.io/htsjdk/',
                    ExternalDependency.MIT_LICENSE_NAME,
                    ExternalDependency.MIT_LICENSE_URL,
                    'A Java API for high-throughput sequencing data (HTS) formats'
            )
    )

    BuildUtils.addLabKeyDependency(project: project, config: "implementation", depProjectPath: ":server:modules:LabDevKitModules:laboratory", depProjectConfig: "apiJarFile")
    BuildUtils.addLabKeyDependency(project: project, config: "apiImplementation", depProjectPath: ":server:modules:LabDevKitModules:laboratory", depProjectConfig: "apiJarFile")
    BuildUtils.addLabKeyDependency(project: project, config: "implementation", depProjectPath: ":server:modules:LabDevKitModules:LDK", depProjectConfig: "apiJarFile")
    BuildUtils.addLabKeyDependency(project: project, config: "apiImplementation", depProjectPath: ":server:modules:LabDevKitModules:LDK", depProjectConfig: "apiJarFile")
    BuildUtils.addExternalDependency(
            project,
            new ExternalDependency(
                    'org.biojava:biojava-core:7.1.1',
                    'biojava-core',
                    'biojava',
                    'http://biojava.org/wiki/Main_Page',
                    ExternalDependency.GNU_LESSER_GPL_21_NAME,
                    ExternalDependency.GNU_LESSER_GPL_21_URL,
                    'Java framework for processing biological data'
            ),
            {
                // Exclude in favor of angus activation from API
                exclude group: 'org.eclipse.angus', module: 'angus-activation'
                exclude group: "jakarta.activation", module: "jakarta.activation-api"
            }
    )

    BuildUtils.addExternalDependency(
            project,
            new ExternalDependency(
                    'org.biojava:biojava-genome:7.1.1',
                    'biojava-genome',
                    'biojava',
                    'http://biojava.org/wiki/Main_Page',
                    ExternalDependency.GNU_LESSER_GPL_21_NAME,
                    ExternalDependency.GNU_LESSER_GPL_21_URL,
                    'Java framework for processing biological data'
            ),
            {
                // Exclude in favor of angus activation from API
                exclude group: 'org.eclipse.angus', module: 'angus-activation'
                exclude group: "jakarta.activation", module: "jakarta.activation-api"
            }
    )

    BuildUtils.addExternalDependency(
            project,
            new ExternalDependency(
                    'org.itadaki:bzip2:0.9.1',
                    'jbzip2',
                    'jbzip2',
                    'http://code.google.com/p/jbzip2/',
                    ExternalDependency.MIT_LICENSE_NAME,
                    ExternalDependency.MIT_LICENSE_URL,
                    'BZIP compression/decompression library.  Used by FastQC'
            )
    )

    BuildUtils.addExternalDependency(
            project,
            new ExternalDependency(
                    'cisd:jhdf5:19.04.1',
                    'JHDF5',
                    'JHDF5',
                    'https://unlimited.ethz.ch/display/JHDF/',
                    ExternalDependency.BSD_LICENSE_NAME,
                    ExternalDependency.BSD_LICENSE_URL,
                    'JHDF5 is a Java binding for HDF5. Used by FastQC'
            )
    )

    BuildUtils.addExternalDependency(
            project,
            new ExternalDependency(
                    'net.iharder:base64:2.3.8',
                    'Base64',
                    'Base64',
                    'http://iharder.net/base64/',
                    ExternalDependency.MIT_LICENSE_NAME,
                    ExternalDependency.MIT_LICENSE_URL,
                    'Library for Base64 encoding. Used by FastQC'
            )
    )
    implementation "net.sf.opencsv:opencsv:${opencsvVersion}"

    // picard brings in a version of servlet-api and a very old one at that, so we excluded it
    // Note: if changing this, we might need to match the htsjdk version set in gradle.properties
    BuildUtils.addExternalDependency(
            project,
            new ExternalDependency(
                    "com.github.broadinstitute:picard:3.1.0",
                    "Picard Tools Lib",
                    "PicardTools",
                    "https://github.com/broadinstitute/picard",
                    ExternalDependency.APACHE_2_LICENSE_NAME,
                    ExternalDependency.APACHE_2_LICENSE_URL,
                    "Manipulating Sequence Data"
            ),
            {
                exclude group: "javax.servlet", module: "servlet-api"
                exclude group: "org.apache.commons", module: "commons-collections4"
                // NOTE: this is a dependency of picard->google-cloud-storage. there is a vunerability in 1.6.8 that does not seem fixed as of 1.6.9
                exclude group: "org.threeten", module: "threetenbp"
            }
    )

    BuildUtils.addExternalDependency(
            project,
            new ExternalDependency(
                    "org.apache.commons:commons-math3:${commonsMath3Version}",
                    "Commons Math",
                    "Apache",
                    "http://commons.apache.org/math/",
                    ExternalDependency.APACHE_2_LICENSE_NAME,
                    ExternalDependency.APACHE_2_LICENSE_URL,
                    "Lightweight, self-contained mathematics and statistics components"
            )
    )
    apiImplementation "org.apache.commons:commons-math3:${commonsMath3Version}"
    BuildUtils.addLabKeyDependency(project: project, config: "modules", depProjectPath: ":server:modules:LabDevKitModules:laboratory", depProjectConfig: "published", depExtension: "module")
    BuildUtils.addLabKeyDependency(project: project, config: "modules", depProjectPath: ":server:modules:LabDevKitModules:LDK", depProjectConfig: "published", depExtension: "module")
    BuildUtils.addLabKeyDependency(project: project, config: "modules", depProjectPath: ":server:modules:DiscvrLabKeyModules:discvrcore", depProjectConfig: "published", depExtension: "module")
}


if (project.findProject(BuildUtils.getTestProjectPath(project.gradle)) != null && project.hasProperty("teamcity"))
{
    project.evaluationDependsOn(BuildUtils.getTestProjectPath(project.gradle))
    def configDir = new File(ServerDeployExtension.getServerDeployDirectory(project), "config")
    def testProject = project.findProject(BuildUtils.getTestProjectPath(project.gradle))
    def createPipelineConfigTask = project.tasks.register("createPipelineConfig", Copy) {
        Copy task ->
            task.group = GroupNames.TEST_SERVER
            task.description = "Create pipeline configs for running tests on the test server"
            task.from project.file("test/configs")
            task.include "pipelineConfig.xml"
            task.filter({ String line ->
                Matcher matcher = PropertiesUtils.PROPERTY_PATTERN.matcher(line)
                def extension = testProject.extensions.findByType(TeamCityExtension.class)
                String newLine = line
                while (matcher.find())
                {
                    if (matcher.group(1).equals("SEQUENCEANALYSIS_TOOLS"))
                        newLine = newLine.replace(matcher.group(), extension.getTeamCityProperty("additional.pipeline.tools"))
                }
                return newLine

            })
            task.destinationDir = configDir

            rootProject.allprojects {
                task.mustRunAfter tasks.withType(DoThenSetup)
            }
    }
    testProject.tasks.named("startTomcat").configure {
        dependsOn(createPipelineConfigTask)
        it.doFirst {
            new File(new File(BuildUtils.getEmbeddedConfigPath(project)), "application.properties")
                    << "\ncontext.pipelineConfig=${configDir.getAbsolutePath().replace("\\", "\\\\")}"
        }
    }
}

project.tasks.register("copyJars", Copy)
        { CopySpec copy ->
            copy.group = "Build"
            copy.description = "Copy commons-math3 JAR to module's lib directory"

            copy.setDuplicatesStrategy(DuplicatesStrategy.EXCLUDE)
            copy.from(project.configurations.external)
            copy.into new File("${project.labkey.explodedModuleLibDir}")
            copy.include {
                "**commons-math3-**.jar"
            }
        }

project.tasks.named('module').configure { dependsOn(project.tasks.copyJars) }
project.tasks.named('copyJars').configure { mustRunAfter(project.tasks.populateExplodedLib) }