build.gradle

import static org.gradle.api.JavaVersion.VERSION_1_8

buildscript {
    ext {
        corda_release_group = 'net.corda'
        corda_release_version = '4.10'
        tokens_release_group = getProperty("group")
        tokens_release_version = getProperty("version")
        tokens_release_suffix= "$versionSuffix"
        corda_gradle_plugins_version = '5.0.12'
        kotlin_version = '1.2.71'
        junit_version = '4.12'
        dokka_version = '0.9.17'
        slf4j_version = '1.7.25'
        log4j_version = '2.9.1'
        jackson_version = '2.9.0'
        confidential_id_release_group = "com.r3.corda.lib.ci"
        confidential_id_release_version = "1.0"
        aetherVersion = '1.0.0.v20140518'
        mavenVersion = '3.1.0'
        maven_resolver_version = "1.1.1"
    }

    repositories {
        mavenCentral()
        mavenLocal()
        maven { url "${publicArtifactURL}/corda-releases" }
        maven { url "${publicArtifactURL}/corda-dependencies" }
        maven { url "https://repo.gradle.org/gradle/libs-releases-local/" }
        // as last resort, check our backup of now defunc JCenter repo
        maven { url "${publicArtifactURL}/jcenter-backup" }
    }

    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath "org.jetbrains.kotlin:kotlin-noarg:$kotlin_version"
        classpath "net.corda.plugins:cordformation:$corda_gradle_plugins_version"
        classpath "net.corda.plugins:quasar-utils:$corda_gradle_plugins_version"
        classpath "net.corda.plugins:cordapp:$corda_gradle_plugins_version"
        classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokka_version"
        classpath "com.gradle:gradle-enterprise-gradle-plugin:$gradleEnterprisePlugin"
        classpath "com.gradle:common-custom-user-data-gradle-plugin:$customUserDataGradlePlugin"
    }
}

plugins {
    id "com.jfrog.artifactory" version "4.16.1"
}

apply plugin: "com.gradle.build-scan"
apply plugin: "com.gradle.common-custom-user-data-gradle-plugin"

buildScan {
    server = gradleEnterpriseUrl
    allowUntrustedServer = false
    def apiKey = project.findProperty('CORDA_GRADLE_SCAN_KEY') ?: System.getenv('CORDA_GRADLE_SCAN_KEY')
    if (apiKey?.trim()) {
        publishAlways()
        capture {
            taskInputFiles = true
        }
        uploadInBackground = false
        accessKey = apiKey
    }
}

allprojects {
    if (tokens_release_suffix.isEmpty()) {
        version tokens_release_version
    } else {
        version "$tokens_release_version-$tokens_release_suffix"
    }
    group "$tokens_release_group"

    configurations.all {
        resolutionStrategy {
            // Force dependencies to use the same version of Kotlin
            force "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
            force "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
            force "org.jetbrains.kotlin:kotlin-stdlib-jre8:$kotlin_version"
            force "org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version"
            force "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"

            cacheChangingModulesFor 0, 'seconds'
        }
    }
}

subprojects {
    repositories {
        mavenCentral()
        mavenLocal()
        maven { url 'https://jitpack.io' }
        maven { url "${publicArtifactURL}/corda-dev" }
        maven { url "${publicArtifactURL}/corda-releases" }
        maven { url "${publicArtifactURL}/corda-lib" }
        maven { url "${publicArtifactURL}/corda-lib-dev" }
        maven { url "https://repo.gradle.org/gradle/libs-releases-local/" }
        maven { url "${publicArtifactURL}/corda-dependencies" }
        // as last resort, check our backup of now defunc JCenter repo
        maven { url "${publicArtifactURL}/jcenter-backup" }
    }

    apply plugin: 'kotlin'

    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile) {
        kotlinOptions {
            languageVersion = "1.2"
            apiVersion = "1.2"
            jvmTarget = VERSION_1_8
            javaParameters = true   // Useful for reflection.
        }
    }

    tasks.withType(Jar) {
        jar {
            exclude "**/log4j2*.xml"
        }
    }

    tasks.withType(Test) {
        minHeapSize = "128m"
        maxHeapSize = "4096m"
    }
}

// Don't publish an empty "modules" JAR.
def publishProjects = [
        project(":contracts"),
        project(":workflows")
]

configure(publishProjects) { Project subproject ->
    apply plugin: 'maven-publish'
    apply plugin: 'com.jfrog.artifactory'

    task sourceJar(type: Jar, dependsOn: subproject.classes) {
        classifier = 'sources'
        from sourceSets.main.allSource
    }

    task javadocJar(type: Jar, dependsOn: subproject.javadoc) {
        classifier = 'javadoc'
        from javadoc.destinationDir
    }

    task install(dependsOn: 'publishToMavenLocal')

    publishing {
        publications {
            create(subproject.name, MavenPublication) {
                from components.java

                groupId subproject.group
                artifactId "tokens-${subproject.name}"
                artifact tasks.sourceJar
                artifact tasks.javadocJar

                pom {
                    name = subproject.name
                    description = subproject.description
                    url = 'https://github.com/corda/token-sdk'
                    scm {
                        url = 'https://github.com/corda/token-sdk'
                    }
                    licenses {
                        license {
                            name = 'Apache-2.0'
                            url = 'https://www.apache.org/licenses/LICENSE-2.0'
                            distribution = 'repo'
                        }
                    }
                    developers {
                        developer {
                            id = 'R3'
                            name = 'R3'
                            email = 'dev@corda.net'
                        }
                    }
                }
            }
        }
    }
}


artifactory {
    publish {
        contextUrl = artifactoryContextUrl
        repository {
            repoKey = 'corda-lib'
            username = System.getenv('CORDA_ARTIFACTORY_USERNAME') ?: System.getProperty('corda.artifactory.username')
            password = System.getenv('CORDA_ARTIFACTORY_PASSWORD') ?: System.getProperty('corda.artifactory.password')
        }

        defaults {
            if (publishProjects.contains(project)) {
                publications(project.name)
            }
        }
    }
}

wrapper {
    gradleVersion = "5.6"
    distributionType = Wrapper.DistributionType.ALL
}

//add for test re-run