build.gradle

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath('io.swagger.codegen.v3:swagger-codegen:3.0.52')
        classpath('com.github.jengelman.gradle.plugins:shadow:2.0.2')
        classpath('io.swagger.codegen.v3:swagger-codegen-generators:1.0.46')
    }
}

plugins {
    id 'idea'
    id 'java-library'
    id 'maven-publish'
    id 'signing'
    id 'org.ajoberstar.grgit' version '2.2.1'
}

import org.ajoberstar.grgit.Grgit

apply from: 'versioning.gradle'

group = applicationGroupId

def codegenJavaDir = "$project.rootDir/generated"
def codegenPythonDir = "$project.rootDir/generated-python"
def codegenJavaSrcDir = codegenJavaDir + "/src/main/java"
def codegenJavaResourceDir = codegenJavaDir + "/src/main/resources"

configurations {
    all {
        resolutionStrategy {
            cacheDynamicVersionsFor 0, 'seconds'
        }

        exclude group: "org.slf4j", module: "slf4j-log4j12"
        exclude group: "log4j", module: "log4j"
        exclude group: "org.eclipse.jetty", module: "jetty-server"
    }

    swaggerCodegen
}

repositories {
    mavenLocal()
    mavenCentral()
}

dependencies {
    swaggerCodegen 'io.swagger.codegen.v3:swagger-codegen:3.0.52'

    implementation 'io.swagger.core.v3:swagger-annotations:2.2.20'
    implementation 'com.squareup.okhttp:okhttp:2.7.5'
    implementation 'com.squareup.okhttp:logging-interceptor:2.7.5'
    implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.16.1'
    implementation 'com.google.code.gson:gson:2.10.1'
    implementation 'joda-time:joda-time:2.12.6'
    implementation 'io.gsonfire:gson-fire:1.9.0'
    implementation 'javax.annotation:javax.annotation-api:1.3.2'

    testImplementation 'junit:junit:4.13.1'
}

ext {
    startTime = new Date().format("yyy-MM-dd'T'HH:mm:ssZ")

    def gitRepo = Grgit.open(dir: projectDir.toString())
    def gitHash = gitRepo.head().id
    def gitBranch = gitRepo.branch.current().name
    def gitBranchFullName = gitRepo.branch.current().fullName
    gitRepo.close()

    currentJvm = Jvm.current()

    if (gitBranch.startsWith('refs/heads/release')) {  // also set in
        project.version = getReleaseVersion()
        println 'Building release: ' + project.version
        artifactoryRepo = 'libs-snapshot-local'
    } else if (gitBranch == 'dev') {
        println 'Building dev branch'
        project.version = getDevVersion(null)
        artifactoryRepo = 'libs-snapshot-local'
    } else {
        def branchVersionIdentifier = gitBranch.replaceAll("\\W", "_")
        println 'Building branch: ' + branchVersionIdentifier
        project.version = getDevVersion(branchVersionIdentifier)
        artifactoryRepo = 'libs-snapshot-local'
    }

    println 'Branch Ref: ' + gitBranchFullName + ' (' + gitHash + ')'
    println 'Version: ' + project.version
}

sourceSets {
    main {
        java {
            srcDirs = [codegenJavaSrcDir]
        }
        resources {
            srcDirs = [codegenJavaResourceDir]
        }
    }
}

java {
    withJavadocJar()
    withSourcesJar()
}

compileJava {
    options.encoding = 'UTF-8'
    options.compilerArgs << "-Xlint:unchecked" << "-Xlint:deprecation"
}

jar {
    manifest {
        attributes(
                'Implementation-Title': project.applicationTitle,
                'Implementation-Version': project.version
        )
    }
}

tasks.named("sourcesJar") {
    mustRunAfter(":generateJavaClient")
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
            version project.version
            pom.withXml {
                asNode().children().last() + {
                    resolveStrategy = Closure.DELEGATE_FIRST
                    name project.applicationTitle
                    description project.applicationDescription
                    url project.url
                    scm {
                        url project.url
                        connection project.scmUrl
                        developerConnection project.scmUrl
                    }
                    licenses {
                        license {
                            name project.licenseName
                            url project.licenseUrl
                            distribution 'repo'
                        }
                    }
                }
            }
        }
    }
    repositories {
        maven {
            url = System.getenv('URL') + '/artifactory/' + artifactoryRepo
            credentials(HttpHeaderCredentials) {
                name = "X-JFrog-Art-API"
                value = System.getenv('TOKEN')
            }
            authentication {
                header(HttpHeaderAuthentication)
            }
        }
    }
}

import io.swagger.codegen.v3.DefaultGenerator
import io.swagger.codegen.v3.CodegenConfigLoader
import io.swagger.codegen.v3.ClientOptInput
import io.swagger.codegen.v3.ClientOpts
import io.swagger.v3.parser.OpenAPIV3Parser
import org.gradle.internal.jvm.Jvm

tasks.register('generateJavaClient') {
    FileTree swaggerFiles = fileTree('.') {
        include 'swagger.yaml'
    }

    inputs.files(swaggerFiles)
    outputs.dir(codegenJavaDir)

    doLast {
        swaggerFiles.each { File file ->
            println "Java Client Generator: processing file - " + file
            def codegenConfig = CodegenConfigLoader.forName('java')
            codegenConfig.setOutputDir(codegenJavaDir)
            codegenConfig.setLibrary('okhttp-gson')
            def options = new ClientOpts()
            options.setProperties([
                    'dateLibrary'  : 'java8',
                    'apiPackage'   : 'com.elyxor.cachethq.api',
                    'modelPackage' : 'com.elyxor.cachethq.model',
                    'sourceFolder' : 'src/main/java',
                    'interfaceOnly': 'true'
            ])
            def openAPI = new OpenAPIV3Parser().read(file.toString(), null, null)
            def clientOpts = new ClientOptInput()
            clientOpts.setOpenAPI(openAPI)
            clientOpts.setConfig(codegenConfig)
            clientOpts.setOpts(options)

            new DefaultGenerator().opts(clientOpts).generate()

        }
    }
}

tasks.register('generatePythonClient') {
    FileTree swaggerFiles = fileTree('.') {
        include 'swagger.yaml'
    }

    inputs.files(swaggerFiles)
    outputs.dir(codegenPythonDir)

    doLast {
        swaggerFiles.each { File file ->
            println "Python Client Generator: processing file - " + file
            def codegenConfig = CodegenConfigLoader.forName('python')
            codegenConfig.setOutputDir(codegenPythonDir)
            def options = new ClientOpts()
            options.setProperties([
                    'packageName': 'cachethq_client',
                    'projectName': 'cachethq-client',
            ])
            def openAPI = new OpenAPIV3Parser().read(file.toString(), null, null)
            def clientOpts = new ClientOptInput()
            clientOpts.setOpenAPI(openAPI)
            clientOpts.setConfig(codegenConfig)
            clientOpts.setOpts(options)

            new DefaultGenerator().opts(clientOpts).generate()

        }
    }
}

tasks.register('copyPyProjectFile', Copy) {
    from "${rootProject.projectDir}/pyproject.toml"
    from "${rootProject.projectDir}/PYPI-README.md"
    into(codegenPythonDir)
}

compileJava.dependsOn generateJavaClient
compileJava.dependsOn generatePythonClient
tasks.generatePythonClient.finalizedBy copyPyProjectFile

clean.doFirst {
    delete(codegenJavaDir)
    delete(codegenPythonDir)
}