build.gradle

import java.nio.file.Paths
import com.github.jk1.license.render.JsonReportRenderer
import com.github.jk1.license.filter.LicenseBundleNormalizer

plugins {
    id "org.jetbrains.kotlin.jvm" version "1.6.0"
    id "com.github.jk1.dependency-license-report" version "1.17"
}

initializeWorkspace()

repositories {
    mavenCentral()
}

ext {
    versionNumber = project.hasProperty('versionNumber') ? property('versionNumber') : 'SNAPSHOT-' + new Date().format('yyyyMMddHHmmss')
    projectIds = ['group': 'teamcity-nuget-support', 'version': versionNumber]

    teamcityVersion = anyParam('teamcityVersion') ?: '2022.10'
    downloadsDir = project.findProperty('downloads.dir') ?: "$rootDir/downloads"
    serversDir = project.findProperty('servers.dir') ?: "$rootDir/servers"
    olingoVersion = '2.0.10'
}

def localRepo = anyParamPath('TC_LOCAL_REPO')

group = projectIds.group
version = projectIds.version

allprojects {
    group = projectIds.group
    version = projectIds.version
}

subprojects { subproject ->
    if (!subproject.name.endsWith("extensions")) {
        apply plugin: "kotlin"

        sourceSets {
            main {
                java {
                    srcDirs = ['src']
                }

                resources {
                    srcDirs = ['resources']
                }
            }

            test {
                java {
                    srcDirs = ['test']
                }

                resources {
                    srcDirs = ['testResources']
                }
            }
        }

        repositories {
            maven { url '../nuget-local-repo' }
            if (localRepo) {
              maven {
                name = "local-teamcity-artifacts"
                url "file:///${localRepo}"
              }
            }
            maven { url 'https://repository.apache.org/snapshots/' }
            mavenCentral()
            mavenLocal()
        }

        test.useTestNG()
        jar.version = null

        tasks.withType(JavaCompile) {
            sourceCompatibility = "1.8"
            targetCompatibility = "1.8"
        }
    }
}

licenseReport {
    renderers = [new JsonReportRenderer('third-party-libraries.json')]
    excludes = ["org.jetbrains.*", "com.jetbrains.*", ".*jackson-bom*"]
    filters = [new LicenseBundleNormalizer(bundlePath: "${project.rootDir}/license-third-party-normalizer.json", createDefaultTransformationRules: false)]
}

def anyParamPath(String... names) {
  def param = anyParam(names);
  if (param == null || param.isEmpty())
    return null
  return (Paths.get(param).isAbsolute()) ?
         Paths.get(param) : getRootDir().toPath().resolve(param)
}

def anyParam(String... names) {
  def param
  try {
    param = names.findResult {
      project.hasProperty(it) ? project.getProperty(it) : System.getProperty(it) ?: System.getenv(it) ?: null
    }
    if (param == null || param.isEmpty())
      param = null
  } finally {
    println("AnyParam: $names -> $param")
  }
  return param
}

def initializeWorkspace() {
  if (System.getProperty("idea.active") != null) {
    println "Attempt to configure workspace in IDEA"
    def coreVersionProperties = project.projectDir.toPath().parent.parent.resolve(".version.properties")
    if (coreVersionProperties.toFile().exists()) {
      def p = new Properties().tap {
        it.load(new FileInputStream(coreVersionProperties.toFile()))
      }
      p.forEach { k,v ->
        System.setProperty(k, v);
      }
    }
  }
}