liquibase.gradle

apply plugin: 'java'
apply plugin: 'groovy'

repositories {
  mavenCentral()
}

dependencies {
  runtime 'org.codehaus.groovy:groovy:2.4.1'
  runtime 'org.codehaus.groovy:groovy-sql:2.4.1'
  runtime 'org.liquibase:liquibase-core:3.3.2'
  runtime 'mysql:mysql-connector-java:5.1.34'
}


database = [:]

def propertiesFilename = System.properties['liquibase.properties'] ?: 'database.properties'
def parentDirectory = (propertiesFilename[0] == '/') ? '/' : projectDir
def propertiesFile = new File(parentDirectory, propertiesFilename)
def properties = new Properties()
if(propertiesFile.exists()) {
  properties.load(new FileInputStream(propertiesFile))
}

database.url = System.properties['database.url'] ?: properties.url
database.username = System.properties['database.username'] ?: properties.username
database.password = System.properties['database.password'] ?: properties.password
database.changeLogFile = System.properties['change.log.file'] ?: properties['change.log.file']
database.workingDir = System.properties['working.dir'] ?: properties['working.dir']
database.classpath = System.properties['database.classpath'] ?: properties['classpath']
database.driver = System.properties['database.driver'] ?: properties['driver']


task generateChangeLog << {
  runLiquibase('generateChangeLog')
}

task changeLogSync << {
  runLiquibase('changeLogSync')
}

task update << {
  liquibaseUpdate(false)
}

task updateSQL << {
  liquibaseUpdate(true)
}

task rollback << {
  liquibaseRollback(false)
}

task rollbackSQL << {
  liquibaseRollback(true)
}

task futureRollbackSQL << {
  runLiquibase('futureRollbackSQL')
}

task updateTestingRollback << {
  runLiquibase('updateTestingRollback')
}

task status << {
  runLiquibase('status')
}

task validate << {
  runLiquibase('validate')
}

task changelogSync << {
  runLiquibase('changelogSync')
}

task changelogSyncSQL << {
  runLiquibase('changelogSyncSQL')
}

task listLocks << {
  runLiquibase('listLocks')
}

task releaseLocks << {
  runLiquibase('releaseLocks')
}

task markNextChangesetRan << {
  runLiquibase('markNextChangesetRan')
}

task markNextChangesetRanSQL << {
  runLiquibase('markNextChangesetRanSQL')
}

task dropAll << {
  runLiquibase('dropAll')
}

task clearChecksums << {
  runLiquibase('clearChecksums')
}

task diff << {
  runLiquibase(["--referenceUrl=${System.properties['liquibase.referenceUrl']}", "--referenceUsername=${System.properties['liquibase.referenceUsername']}", "--referencePassword=${System.properties['liquibase.referencePassword']}", 'diff'])
}

task tag << {
  runLiquibase(['tag', "${System.properties('liquibase.tag')}"])
}

task dbDoc << {
  runLiquibase([ 'dbDoc', System.properties['liquibase.doc.dir'] ?: "${buildDir.absolutePath}/database/docs"])
}

def liquibaseRollback(dryRun) {
  def argList = []
  def tag = System.properties['liquibase.tag']
  def count = System.properties['liquibase.count']
  def date = System.properties['liquibase.date']

  def suffix = ''
  def param = ''
  if(count) {
    suffix = 'rollbackCount'
    param = count
  }
  else if(date) {
    suffix = 'rollbackToDate'
    param = date
  }
  else {
    suffix = 'rollback'
    param = tag
  }

  if(dryRun) {
    suffix = suffix + 'SQL'
  }

  argList << suffix
  argList << param

  runLiquibase(argList)
}


def liquibaseUpdate(dryRun) {
  def suffix = ''
  def count = System.properties['liquibase.count']
  if(count) {
    suffix = 'Count'
  }
  if(dryRun) {
    suffix = suffix + 'SQL'
  }

  def argList = [ "update${suffix}" ]

  if(count) {
    argList << count
  }

  runLiquibase(argList)
}


def runLiquibase(String command) {
  runLiquibase([command])
}

def runLiquibase(List argList) {
  def contexts = System.properties['liquibase.contexts']
  def stdArgs = ["--url=${project.database.url}", "--username=${project.database.username}", "--password=${project.database.password}"]

  if(project.database.changeLogFile) {
    stdArgs << "--changeLogFile=${project.database.changeLogFile}"
  }
  if(project.database.driver) {
    stdArgs << "--driver=${project.database.driver}"
  }
  if(project.database.classpath) {
    stdArgs << "--classpath=${project.database.classpath}"
  }
  if(contexts) {
    stdArgs << "--contexts=${contexts}"
  }

  javaexec {
    workingDir =  database.workingDir ?: projectDir
    main = 'liquibase.integration.commandline.Main'
    classpath = sourceSets.main.runtimeClasspath
    args = stdArgs + argList
  }
}