build.gradle

buildscript { //properties that you need to build the project

    ext.artifactory_contextUrl = 'https://software.r3.com/artifactory'
    ext.publicArtifactURL = 'https://download.corda.net/maven'

    repositories {
        mavenLocal()
        mavenCentral()
        maven { url "${publicArtifactURL}/jcenter-backup" }
        maven { url "${publicArtifactURL}/corda-releases" }
    }

    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        classpath "net.corda.plugins:cordapp:$corda_gradle_plugins_version"
        classpath "net.corda.plugins:cordformation:$corda_gradle_plugins_version"
        classpath "net.corda.plugins:quasar-utils:$corda_gradle_plugins_version"
    }
}

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

// You can define this property in ~/.gradle/gradle.properties on your dev box.
if (! project.hasProperty('cordaArtifactoryUsername') || !ext.cordaArtifactoryUsername?.trim()) {
    ext.cordaArtifactoryUsername = System.getenv('CORDA_ARTIFACTORY_USERNAME')
            ?: System.getenv('ARTIFACTORY_USERNAME')
            ?: System.getProperty('corda.artifactory.username')
}

// You can define this property in ~/.gradle/gradle.properties on your dev box.
if (! project.hasProperty('cordaArtifactoryPassword') || !ext.cordaArtifactoryPassword?.trim()) {
    ext.cordaArtifactoryPassword = System.getenv('CORDA_ARTIFACTORY_PASSWORD')
            ?: System.getenv('ARTIFACTORY_PASSWORD')
            ?: System.getProperty('corda.artifactory.password')
}

allprojects { //Properties that you need to compile your project (The application)
    version reissuance_version
    group reissuance_group

    apply from: "${rootProject.projectDir}/repositories.gradle"
    apply plugin: 'kotlin'

    repositories {
        mavenLocal()
        maven { url "${publicArtifactURL}/jcenter-backup" }
        mavenCentral()
        maven { url "${publicArtifactURL}/corda-releases" }
        maven { url "${publicArtifactURL}/corda-dependencies" }
        maven { url "https://jitpack.io" }
        maven { url "${publicArtifactURL}/corda-lib" }
    }

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

    jar {
        // This makes the JAR's SHA-256 hash repeatable.
        preserveFileTimestamps = false
        reproducibleFileOrder = true
    }
}

apply plugin: 'net.corda.plugins.cordapp'
apply plugin: 'net.corda.plugins.cordformation'
apply plugin: 'net.corda.plugins.quasar-utils'

sourceSets {
    main {
        resources {
            srcDir rootProject.file("config/dev")
        }
    }
}

//Module dependencis
dependencies {
    // Corda dependencies.
    cordaCompile "$corda_core_release_group:corda-core:$corda_core_release_version"
    cordaRuntime "$corda_release_group:corda-node-api:$corda_release_version"
    cordaRuntime "$corda_release_group:corda:$corda_release_version"

    // CorDapp dependencies.
    cordapp project(":workflows")
    cordapp project(":contracts")
    cordapp project(":dummy_contracts")
    cordapp project(":dummy_workflows")

    cordaCompile "org.apache.logging.log4j:log4j-slf4j-impl:${log4j_version}"
    cordaCompile "org.apache.logging.log4j:log4j-web:${log4j_version}"
    cordaCompile "org.slf4j:jul-to-slf4j:$slf4j_version"

    // CI dependencies
    cordapp "$confidential_id_release_group:ci-workflows:$confidential_id_release_version"


    // Token SDK dependencies.
    cordapp "$tokens_release_group:tokens-contracts:$tokens_release_version"
    cordapp "$tokens_release_group:tokens-workflows:$tokens_release_version"
}

//Task to build the jar for ganache.
task ganache {
    subprojects {
        if (it.project.name != "clients") {
            dependsOn jar
            doLast {
                copy {
                    from "${buildDir}/libs"
                    into "${rootDir}/build/libs"
                }
            }
        }
    }
}

//Task to deploy the nodes in order to bootstrap a network
task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {

    /* This property will load the CorDapps to each of the node by default, including the Notary. You can find them
     * in the cordapps folder of the node at build/nodes/Notary/cordapps. However, the notary doesn't really understand
     * the notion of cordapps. In production, Notary does not need cordapps as well. This is just a short cut to load
     * the Corda network bootstrapper.
     */
    nodeDefaults {
        projectCordapp {
            deploy = false
        }

        cordapp "$tokens_release_group:tokens-contracts:$tokens_release_version"
        cordapp "$tokens_release_group:tokens-workflows:$tokens_release_version"

        cordapp "$confidential_id_release_group:ci-workflows:$confidential_id_release_version"

        cordapp project(':dummy_contracts')
        cordapp project(':dummy_workflows')
        cordapp project(':contracts')
        cordapp project(':workflows')

        runSchemaMigration = true
    }
    node {
        name "O=Notary,L=London,C=GB"
        notary = [validating : false]
        p2pPort 10002
        rpcSettings {
            address("localhost:10003")
            adminAddress("localhost:10043")
        }
        extraConfig = ['custom.jvmArgs': ["-Xmx2G"]]
    }
    node {
        name "O=Issuer,L=London,C=GB"
        p2pPort 10005
        rpcSettings {
            address("localhost:10006")
            adminAddress("localhost:10046")
        }
        rpcUsers = [[ user: "user1", "password": "test", "permissions": ["ALL"]]]
        extraConfig = ['custom.jvmArgs': ["-Xmx2G"]]
    }
    node {
        name "O=Alice,L=New York,C=US"
        p2pPort 10008
        rpcSettings {
            address("localhost:10009")
            adminAddress("localhost:10049")
        }
        rpcUsers = [[ user: "user1", "password": "test", "permissions": ["ALL"]]]
        extraConfig = ['custom.jvmArgs': ["-Xmx2G"]]
    }
    node {
        name "O=Bob,L=San Francisco,C=US"
        p2pPort 10010
        rpcSettings {
            address("localhost:10011")
            adminAddress("localhost:10052")
        }
        rpcUsers = [[ user: "user1", "password": "test", "permissions": ["ALL"]]]
        extraConfig = ['custom.jvmArgs': ["-Xmx2G"]]
    }

}


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

configure(publishProjects) { 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 "reissuance-cordapp-${subproject.name}"
                artifact tasks.sourceJar
                artifact tasks.javadocJar

                pom {
                    description = subproject.description
                }
            }
        }
    }
}


artifactory {
    publish {
        contextUrl = "${artifactory_contextUrl}"
        repository {
            repoKey = project.hasProperty("publishRepo") ? project.property("publishRepo") : ""
            username = cordaArtifactoryUsername
            password = cordaArtifactoryPassword
        }

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