build.gradle

import java.nio.file.Paths

plugins {
  id 'io.github.rodm.teamcity-server' version '1.5.2'
  id 'org.jetbrains.kotlin.jvm' version '1.3.41'
}

initializeWorkspace()

apply plugin: 'java'
apply plugin: 'com.github.rodm.teamcity-server'
apply plugin: 'idea'

ext {
  teamcityVersion = anyParam('teamcityVersion') ?: '2022.02'
  versionNumber = anyParam('versionNumber') ?: 'SNAPSHOT-' + new Date().format('yyyyMMddHHmmss')
}
def localRepo = anyParamPath('TC_LOCAL_REPO')

group = 'jetbrains.buildServer.investigationsAutoAssigner'

version = versionNumber



// Remove repositories added by plugins
project.plugins.withType(JavaPlugin) {
  project.repositories.clear()
}

repositories {
  if (localRepo) {
    maven {
      name = "local-teamcity-artifacts"
      url "file:///${localRepo}"
    }
  }
  maven { url "https://download.jetbrains.com/teamcity-repository" }
  mavenCentral()
  mavenLocal()
}

configurations {
}

dependencies {
  provided(group: 'org.jetbrains.teamcity.internal', name: 'server', version: "${teamcityVersion}")
  testCompile 'org.mockito:mockito-core:2.18.0'
  testCompile 'org.assertj:assertj-core:2.2.0'
  testCompile 'com.google.jimfs:jimfs:1.1'
  testCompile "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
  testCompile 'org.awaitility:awaitility:3.1.6'
}

sourceCompatibility = "1.8"
targetCompatibility = "1.8"

test {
  useTestNG()
}

teamcity {
  version = teamcityVersion
  allowSnapshotVersions = true

  server {
    descriptor {
      name = project.name
      displayName = 'Investigations Auto-Assigner'
      version = project.version
      vendorName = 'JetBrains'
      vendorUrl = 'http://www.jetbrains.com/'
      description = 'Automatically assigns investigations according to a set of rules.'

      useSeparateClassloader = true
      nodeResponsibilitiesAware = true

      files {
        into('kotlin-dsl') {
          from("${rootProject.projectDir}/kotlin-dsl")
        }
      }
    }
  }

}

// Do not include version into plugin archive name
serverPlugin.version = null

idea {
  module {
    downloadJavadoc = false
    downloadSources = true
  }
}


compileKotlin {
  kotlinOptions {
    jvmTarget = "1.8"
  }
}

compileTestKotlin {
  kotlinOptions {
    jvmTarget = "1.8"
  }
}

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.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);
      }
    }
  }
}