build.gradle

buildscript {
  repositories {
    mavenCentral()
    maven {
      url 'https://artifactory.wetransform.to/artifactory/libs-release-local'
    }
    maven {
      url 'https://artifactory.wetransform.to/artifactory/libs-snapshot-local'
    }
  }
  dependencies {
    classpath 'to.wetransform.hale:gradle-hale-plugin:2.0.0'
    classpath 'commons-io:commons-io:2.16.1'
  }
}

plugins {
  id 'distribution'
}

apply plugin: 'to.wetransform.hale'

hale {
  cliVersion = '5.3.0'
}

import org.apache.commons.io.FileUtils

/*
 * Configuration file
 */

gradle.startParameter.continueOnFailure = true

project.ext.configBasePath = project.file(project.hasProperty('configBasePath') ? project.getProperty('configBasePath') : '.')
def json = new groovy.json.JsonSlurper()
def config = json.parse(file(project.hasProperty('configFile') ? project.getProperty('configFile') : 'config.json'))

def summaryFile = new File(project.ext.configBasePath, 'Zusammenfassung.log')

/*
 * Transformation tasks
 */

task('transform-all') {
  description 'Führt alle Transformationen durch'
  group 'Transformation'
}

task('validate-all') {
  description 'Führt alle Validierungen durch'
  group 'Validierung'
}

task('clean-all-validations') {
  description 'Entfernt alle Ausgaben der Validierungsläufe'
  group 'Validierung'
}

task('aggregate-all') {
  description 'Führt alle Aggregationen durch'
  group 'Aggregation'
}

task('clean-all-aggregations') {
  description 'Entfernt alle Ausgaben der Aggregtionsläufe'
  group 'Aggregation'
}

task('clean-all') {
  description 'Entfernt alle Ausgaben der Validierungs- und Aggregationsläufe'
  group 'DF7_10'

  dependsOn 'clean-all-validations'
  dependsOn 'clean-all-aggregations'
}

task('prepare-validation-summary').doFirst {
  summaryFile.withWriterAppend('utf8') { out ->
    out.append('\n')
    out.append('==================================================\n')
    out.append("Validierungslauf ${new Date().toString()}\n")
    out.append('==================================================\n')
  }
}

task('prepare-aggregation-summary').doFirst {
  summaryFile.withWriterAppend('utf8') { out ->
    out.append('\n')
    out.append('==================================================\n')
    out.append("Aggregationslauf ${new Date().toString()}\n")
    out.append('==================================================\n')
  }
}

config.validations.each { name, settings ->
    def projectFile = new File(configBasePath, settings.project)

    String targetName = "$name"
    File targetFolder = settings.targetFolder ? new File(configBasePath, settings.targetFolder) : new File('result', targetName)

    def vg250Folder = new File(configBasePath, config.coverageArea.vg250Folder)

    task("validate-$name-all") {
      description "Führt alle Validierungen für $name durch"
      group 'Validierung'
    }

    def inputFolder = new File(configBasePath, settings.table.path)
    if (inputFolder.exists()) {
      inputFolder.eachDir { d ->

        File logFileFolder = new File(targetFolder, d.name)
        logFileFolder.mkdirs()

        task("validate-$name-${d.name}") {
          description "Führt alle Validierungen für ${d.name} durch"
          group 'Validierung'
        }

        task("validate-$name-${d.name}-plan", type: hale.transform()) {
          assert projectFile != null
          transformation = projectFile

          logToConsole = false
          logFolder = logFileFolder

          if (settings.sheets) {
            settings.sheets.each { s ->
              source(d) {
                include '*.xlsx'
                provider 'eu.esdihumboldt.hale.io.xls.reader.instance'
                setting 'contentType', 'eu.esdihumboldt.hale.io.xls.xlsx'
                setting 'skip', "${s.skip}"
                setting 'sheetIndex', "${s.index}"
                setting 'typename', "${s.typename}"
                setting 'dateTimeFormatterDefault', '[dd.MM.yyyy]'
              }
            }
          }
          else {
            source(d) {
              include '*.xlsx'
              provider 'eu.esdihumboldt.hale.io.xls.reader.instance'
              setting 'contentType', 'eu.esdihumboldt.hale.io.xls.xlsx'
              setting 'skip', '0'
              setting 'multiSheet', 'true'
              setting 'dateTimeFormatterDefault', '[dd.MM.yyyy]'
            }
          }

          settings.additionalSources?.each { src ->
            def additionalSourceFolder
            if (src.folder) {
              additionalSourceFolder = new File(configBasePath, src.folder)
            }
            else {
              additionalSourceFolder = d
            }
            source(additionalSourceFolder) {
              include src.includePattern
              provider src.provider
              setting 'contentType', "${src.contentType}"
            }
          }

          target(new File(logFileFolder, settings.targetFileName ?: 'output.xlsx')) {
            preset 'default'
          }

          printStacktrace = true
          trustGroovy = true
          ignoreExitValue = false

          additionalArgs << '-statisticsOut'
          additionalArgs << "${logFileFolder}/statistics.json"
          additionalArgs << '-reportsOut'
          additionalArgs << "${logFileFolder}/reports.out"
          additionalArgs << '-successEvaluation'
          additionalArgs << 'successEvaluation.groovy'

          description "Eingabedaten auf Basis des hale»studio-Projekts \"${projectFile.name}\" validieren."
          group 'Validierung'

          dependsOn 'prepare-validation-summary'
          finalizedBy "finalize-$name-${d.name}-plan"
        }

        tasks["validate-$name-${d.name}-plan"].doFirst {
          targetFolder.mkdirs()
          logFileFolder.mkdirs()
        }

        task("finalize-$name-${d.name}-plan").doLast {
          def outputFile = new File(logFileFolder, 'LAP_HVS_2024_v230717_validation.xlsx')
          def renamedFile = new File(logFileFolder, "DF7_10_NAP_MajorRoads_${d.name}.xlsx")
          outputFile.renameTo(renamedFile)
        }

        task("clean-validation-$name-${d.name}") {
          group 'Validierung'
        }.doLast {
          if (targetFolder.exists()) {
            FileUtils.cleanDirectory(targetFolder)
          }
        }

        tasks['clean-all'].dependsOn("clean-validation-$name-${d.name}")

        tasks["validate-$name-${d.name}"].dependsOn("validate-$name-${d.name}-plan")
        tasks['validate-all'].dependsOn("validate-$name-${d.name}-plan")
        tasks["validate-$name-all"].dependsOn("validate-$name-${d.name}-plan")

        if (settings.coverageArea) {
          def coverageAreaLogFolder = new File(logFileFolder, 'logs_coverage_area')
          coverageAreaLogFolder.mkdirs()

          task("validate-$name-${d.name}-coveragearea", type: hale.transform()) {
            transformation = new File(configBasePath, config.coverageArea.validationProject)

            logToConsole = false
            logFolder = coverageAreaLogFolder

            source(d) {
              include '*.xlsx'
              provider 'eu.esdihumboldt.hale.io.xls.reader.instance'
              setting 'contentType', 'eu.esdihumboldt.hale.io.xls.xlsx'
              setting 'skip', '0'
              setting 'sheetIndex', '0'
              setting 'typename', 'Allgemeines'
              setting 'dateTimeFormatterDefault', '[dd.MM.yyyy]'
            }

            source(d) {
              include '*.shp'
              provider 'eu.esdihumboldt.hale.io.shape.reader.instance'
              setting 'contentType', 'eu.esdihumboldt.hale.io.shp'
              setting 'autoDetectSchemaTypes', 'false'
              setting 'typename', '{http://www.esdi-humboldt.eu/hale/shp}LAP_Gebiet'
            }

            source(vg250Folder) {
              include 'VG250_GEM.shp'
              provider 'eu.esdihumboldt.hale.io.shape.reader.instance'
              setting 'contentType', 'eu.esdihumboldt.hale.io.shp'
              setting 'autoDetectSchemaTypes', 'false'
              setting 'typename', '{http://www.esdi-humboldt.eu/hale/shp}VG250_GEM'
            }

            source(vg250Folder) {
              include 'VG250_RBZ.shp'
              provider 'eu.esdihumboldt.hale.io.shape.reader.instance'
              setting 'contentType', 'eu.esdihumboldt.hale.io.shp'
              setting 'autoDetectSchemaTypes', 'false'
              setting 'typename', '{http://www.esdi-humboldt.eu/hale/shp}VG250_RBZ'
            }

            source(vg250Folder) {
              include 'VG250_VWG.shp'
              provider 'eu.esdihumboldt.hale.io.shape.reader.instance'
              setting 'contentType', 'eu.esdihumboldt.hale.io.shp'
              setting 'autoDetectSchemaTypes', 'false'
              setting 'typename', '{http://www.esdi-humboldt.eu/hale/shp}VG250_VWG'
            }

            target(new File(logFileFolder, 'LAP_Gebiet.gpkg')) {
              preset 'default'
            }

            printStacktrace = true
            trustGroovy = true
            ignoreExitValue = false

            additionalArgs << '-statisticsOut'
            additionalArgs << "${coverageAreaLogFolder}/statistics_coveragearea.json"
            additionalArgs << '-reportsOut'
            additionalArgs << "${coverageAreaLogFolder}/reports_coveragearea.out"
            additionalArgs << '-successEvaluation'
            additionalArgs << 'successEvaluation.groovy'

            description "Gültigkeitsbereich auf Basis des hale»studio-Projekts \"${config.coverageArea.validationProject}\" validieren."
            group 'Validierung'

            dependsOn 'prepare-validation-summary'
            finalizedBy "finalize-$name-${d.name}-coveragearea"
          }

          task("finalize-$name-${d.name}-coveragearea").doLast {
            def outputFile = new File(logFileFolder, 'LAP_Gebiet.gpkg')
            def renamedFile = new File(logFileFolder, "LAP_Gebiet_${d.name}.gpkg")
            outputFile.renameTo(renamedFile)
          }

          tasks["validate-$name-${d.name}"].dependsOn("validate-$name-${d.name}-coveragearea")
          tasks['validate-all'].dependsOn("validate-$name-${d.name}-coveragearea")
          tasks["validate-$name-all"].dependsOn("validate-$name-${d.name}-coveragearea")
        }
      }
    }
}

config.aggregations.each { name, settings ->
    def projectFile = new File(configBasePath, settings.project)

    String targetName = "$name"
    File targetFolder = settings.targetFolder ? new File(configBasePath, settings.targetFolder) : new File('result', targetName)

    def inputFolder = new File(configBasePath, settings.table.path)

    task("aggregate-$name") {
      description "Validierte Daten und Gültigkeitsbereiche für $name aggregieren."
      group 'Aggregation'
    }

    task("aggregate-$name-plan", type: hale.transform()) {
      assert projectFile != null
      transformation = projectFile

      logToConsole = false
      logFolder = targetFolder

      if (inputFolder.exists()) {
        inputFolder.eachDir { d ->
          source(d) {
            include '*.xlsx'
            provider 'eu.esdihumboldt.hale.io.xls.reader.instance'
            setting 'contentType', 'eu.esdihumboldt.hale.io.xls.xlsx'
            setting 'skip', '1'
            setting 'multiSheet', 'true'
            setting 'dateTimeFormatterDefault', '[dd.MM.yyyy]'
          }

          source(d) {
            include '*.gpkg'
            provider 'eu.esdihumboldt.hale.io.geopackage.instance.reader'
            setting 'contentType', 'eu.esdihumboldt.hale.io.geopackage'
          }
        }
      }

      target(new File(targetFolder, settings.targetFileName ?: 'output.xlsx')) {
        preset 'default'
      }

      printStacktrace = true
      trustGroovy = true
      ignoreExitValue = false

      additionalArgs << '-statisticsOut'
      additionalArgs << "${targetFolder}/statistics.json"
      additionalArgs << '-reportsOut'
      additionalArgs << "${targetFolder}/reports.out"
      additionalArgs << '-successEvaluation'
      additionalArgs << 'successEvaluation.groovy'

      description "Validierte Daten auf Basis des hale»studio-Projekts \"${projectFile.name}\" aggregieren."
      group 'Aggregation'

      dependsOn 'prepare-aggregation-summary'
    }

    tasks["aggregate-$name-plan"].doFirst {
      targetFolder.mkdirs()
    }

    tasks["aggregate-$name"].dependsOn("aggregate-$name-plan")
    tasks['aggregate-all'].dependsOn("aggregate-$name")

    task("clean-aggregation-$name") {
      description "Entfernt die Aggregationsergebnisse für $name"
      group 'Aggregation'
    }.doLast {
      if (targetFolder.exists()) {
        FileUtils.cleanDirectory(targetFolder)
      }
    }

    if (settings.coverageArea) {
      def coverageAreaLogFolder = new File(targetFolder, 'logs_coverage_area')
      coverageAreaLogFolder.mkdirs()

      task("aggregate-$name-coveragearea", type: hale.transform()) {
        assert projectFile != null
        transformation = new File(configBasePath, config.coverageArea.aggregationProject)

        logToConsole = false
        logFolder = coverageAreaLogFolder

        if (inputFolder.exists()) {
          inputFolder.eachDir { d ->
            source(d) {
              include '*.gpkg'
              provider 'eu.esdihumboldt.hale.io.geopackage.instance.reader'
              setting 'contentType', 'eu.esdihumboldt.hale.io.geopackage'
            }
          }
        }

        target(new File(targetFolder, "LAP_Gebiet_${name}_aggregated.gpkg")) {
          preset 'default'
        }

        printStacktrace = true
        trustGroovy = true
        ignoreExitValue = false

        additionalArgs << '-statisticsOut'
        additionalArgs << "${coverageAreaLogFolder}/statistics_coveragearea.json"
        additionalArgs << '-reportsOut'
        additionalArgs << "${coverageAreaLogFolder}/reports_coveragearea.out"
        additionalArgs << '-successEvaluation'
        additionalArgs << 'successEvaluation.groovy'

        description "Gültigkeitsbereiche auf Basis des hale»studio-Projekts \"${config.coverageArea.aggregationProject}\" aggregieren."
        group 'Aggregation'

        dependsOn 'prepare-aggregation-summary'
        dependsOn "clean-aggregation-$name"
      }

      tasks["aggregate-$name"].dependsOn("aggregate-$name-coveragearea")
    }

    tasks['clean-all-aggregations'].dependsOn("clean-aggregation-$name")
}

config.targetEPSG.each { epsg ->
  config.transformations.each { name, settings ->

    def projectFile = new File(configBasePath, settings.project)

    // target
    String targetName = "$name-$epsg"
    File targetFolder = settings.targetFolder ? new File(configBasePath, settings.targetFolder) : new File('result', targetName)

    task("transform-$name-$epsg", type: hale.transform()) {
      assert projectFile != null
      transformation = projectFile

      settings.shapefiles.each { shapefile ->
        source(new File(configBasePath, shapefile.path)) {
          provider 'eu.esdihumboldt.hale.io.shape.reader.instance'
          include "${shapefile.filename}"
          setting 'contentType', 'eu.esdihumboldt.hale.io.shp'
          setting 'typename', "${shapefile.typename}"
        }
      }

      settings.table.sheets.each { sheet ->
        source(new File(configBasePath, settings.table.path)) {
          provider 'eu.esdihumboldt.hale.io.xls.reader.instance'
          setting 'contentType', 'eu.esdihumboldt.hale.io.xls.xlsx'
          setting 'typename', "${sheet.typename}"
          setting 'sheetIndex', "${sheet.index}"
          setting 'skip', '2'
        }
      }

      if (settings.sourceFilter) {
        filterArgs << '-filter'
        filterArgs << settings.sourceFilter
      }

      logFolder = targetFolder

      target(new File(targetFolder, settings.targetFileName ?: 'output.gpkg')) {
        provider 'eu.esdihumboldt.hale.io.geopackage.instance.writer'

        setting 'crs', "code:EPSG:$epsg"
      }

      // XML schema validation
      // validate('eu.esdihumboldt.hale.io.xml.validator')

      printStacktrace = true
      trustGroovy = true

      // ignore failure -> task will be successful
      ignoreExitValue = true

      description "Runs a transformation based on the project ${projectFile.name}."
      group 'Transformation'
    }

    tasks["transform-$name-$epsg"].doFirst {
      targetFolder.mkdirs()
      FileUtils.cleanDirectory(targetFolder)
    }
    
    tasks['transform-all'].dependsOn("transform-$name-$epsg")
  }
}


configurations.all {
  resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
}

distributions {
  main {
    distributionBaseName = 'uba-end-automation'
    contents {
      from('.') {
        include '*'
        include 'gradle/**'
        exclude '.git'
        exclude '.github'
        exclude '.gitignore'
        exclude '.gradle'
        exclude '.releaserc.yml'
        exclude '.vscode'
        exclude '.wetf-repo.yml'
        exclude '*.log'
        exclude 'gradle.properties'
        exclude 'build/**'
        exclude 'workspace'
      }
    }
  }
}


/*
 * Gradle wrapper
 */
wrapper {
  gradleVersion = '8.10'
}