elasticSearch.client.mode = '<mode>'

elasticSearch.client.hosts = [
       [host:'192.168.0.3', port:9300],
       [host:'228.168.0.4', port:9300]
]

elasticSearch {
  /**
   * Date formats used by the unmarshaller of the JSON responses
   */
  date.formats = ["yyyy-MM-dd'T'HH:mm:ss'Z'"]
  /**
   * Hosts for remote ElasticSearch instances.
   * Will only be used with the "transport" client mode.
   * If the client mode is set to "transport" and no hosts are defined, ["localhost", 9300] will be used by default.
   */
  client.hosts = [
          [host:'localhost', port:9300]
  ]
  /**
   * Default mapping property exclusions
   *
   * No properties matching the given names will be mapped by default
   * ie, when using "searchable = true"
   *
   * This does not apply for classes using mapping by closure
   */
  defaultExcludedProperties = ["password"]
  /**
   * Determines if the plugin should reflect any database save/update/delete automatically
   * on the ES instance. Default to false.
   */
  disableAutoIndex = false
  /**
   * Should the database be indexed at startup.
   *
   * The value may be a boolean true|false.
   * Indexing is always asynchronous (compared to Searchable plugin) and executed after BootStrap.groovy.
   */
  bulkIndexOnStartup = true
  /**
   *  Max number of requests to process at once. Reduce this value if you have memory issue when indexing a big amount of data
   *  at once. If this setting is not specified, 500 will be use by default.
   */
  maxBulkRequest = 500
}
environments {
  development {
    /**
     * Possible values : "local", "node", "transport"
     * If set to null, "node" mode is used by default.
     */
    elasticSearch.client.mode = 'local'
  }
  test {
      elasticSearch {
          client.mode = 'local'
          index.store.type = 'memory' // store local node in memory and not on disk
      }
  }
  production {
    elasticSearch.client.mode = 'node'
  }
}

static searchable = true

static searchable = {
    // mapping DSL…
}

class Tweet {
    static searchable = {
        only = 'message'
    }
    String message
    String someUselessField
}

class Tweet {
    static searchable = {
        except = 'someUselessField'
    }
    String message
    String someUselessField
}

class Tweet {
    static searchable = {
        except = ['someUselessField', 'userName']
    }
    String message
    String userName
    String someUselessField
}

class Preference {
    static searchable = {
        root false
    }
    // …
}
class Tag {
    static searchable = true
    // …
}
class Tweet {
    static searchable = {
        message boost:2.0
    }
    // …
}

class User {
    static searchable = {
        userPreferences component:true
    }
    Preference userPreferences
}

static searchable = {
    propertyName option1:value, option2:value, …
}

class MyDomain {
    // odom is an association with the OtherDomain class, set as a reference
    OtherDomain odom
    static searchable = {
        odom reference:true
    }
}
// The OtherDomain definition, with default searchable configuration
class OtherDomain {
    static searchable = true
    String field1 = "val1"
    String field2 = "val2"
    String field3 = "val3"
    String field4 = "val4"
}

{
    "mydomain": {
        "_id":1,
        "odom": { "id":1 }
    }
}
{
    "otherdomain": {
        "_id":1,
        "field1":"val1",
        "field2":"val2",
        "field3":"val3",
        "field4":"val4"
    }
}

class MyDomain {
    // odom is an association with the OtherDomain class, set as a reference
    OtherDomain odom
    static searchable = {
        odom component:true
    }
}
// The OtherDomain definition, with default searchable configuration
class OtherDomain {
    static searchable = true
    String field1 = "val1"
    String field2 = "val2"
    String field3 = "val3"
    String field4 = "val4"
}

{
    "mydomain": {
        "_id":1,
        "odom": {
            "_id":1,
            "field1":"val1",
            "field2":"val2",
            "field3":"val3",
            "field4":"val4"
        }
    }
}

// Index all searchable instances
elasticSearchService.index()
// Index a specific domain instance
MyDomain md = new MyDomain(value:'that')
md.save()
elasticSearchService.index(md)
// Index a collection of domain instances
def ds = [new MyDomain(value:'that'), new MyOtherDomain(name:'this'), new MyDomain(value:'thatagain')]
ds*.save()
elasticSearchService.index(ds)
// Index all instances of the specified domain class
elasticSearchService.index(MyDomain)
elasticSearchService.index(class:MyDomain)
elasticSearchService.index(MyDomain, MyOtherDomain)
elasticSearchService.index([MyDomain, MyOtherDomain])

// Unindex all searchable instances
elasticSearchService.unindex()
// Unindex a specific domain instance
MyDomain md = new MyDomain(value:'that')
md.save()
elasticSearchService.unindex(md)
// Unindex a collection of domain instances
def ds = [new MyDomain(value:'that'), new MyOtherDomain(name:'this'), new MyDomain(value:'thatagain')]
ds*.save()
elasticSearchService.unindex(ds)
// Unindex all instances of the specified domain class
elasticSearchService.unindex(MyDomain)
elasticSearchService.unindex(class:MyDomain)
elasticSearchService.unindex(MyDomain, MyOtherDomain)
elasticSearchService.unindex([MyDomain, MyOtherDomain])

def res = elasticSearchService.search("${params.query}")
// 'res' search results may contains multiple types of results

def res = Tweet.search("${params.query}")
// 'res' search results contains only Tweet instances

def res = Tweet.search("${params.query}")
println "Found ${res.total} result(s)"
res.searchResults.each {
    println it.message
}
def res = elasticSearchService.search("${params.query}")
println "Found ${res.total} result(s)"
res.searchResults.each {
    if(it instanceof Tweet) {
        println it.message
    } else {
        println it.toString()
    }
}

def res = Tweet.countHits("${params.query}")
println "Found ${res} result(s)"
def res = elasticSearchService.countHits("${params.query}", [indices:'test'])
println "Found ${res} result(s)"

def results = elasticSearchService.search("${params.query}")
def resultsTweets = Tweet.search("message:${params.query}")

def result = elasticSearchService.search(searchType:'dfs_query_and_fetch') {
  bool {
      must {
          query_string(query: params.query)
      }
      if (params.firstname) {
          must {
              term(firstname: params.firstname)
          }
      }
  }
}

// Define the pre & post tag that will wrap each term matched in the document.
def highlighter = {
  field 'message'
  field 'tags.name'
  preTags '<strong>'
  postTags '</strong>'
}
def results = Tweet.search("${params.query}", [highlight: highlightSettings])

def results = Tweet.search("${params.query}", [highlight: { field 'message' }])
def highlighted = results.highlight
results?.searchResults?.eachWithIndex { hit, index ->
    // Retrieve the 'message' field fragments for the current hits
    def fragments = highlighted[index].message?.fragments
    // Print the fragment
    println fragments?.size() ? fragments[0] : ''
}

field <fieldName>[, <fragmentSize>[, <numberOfFragment>]]

def highlightSettings = {
    field 'message'                    // Add the 'message' field in the highlighted fields list
    field 'tags.name'                  // Add the 'name' field contained in the 'tags' field of
                                       // the document in the highlighted fields list
    field 'thatAwesomeField', 0, 20    // Add the 'thatAwesomeField' field with
                                       // some values fixed for fragmentSize and numberOfFragment parameters
}
def highlightSettings2 = {
    field '_all'                       // Add the special '_all' field in the highlighted fields list
}
def results = Tweet.search("${params.query}", [highlight: highlightSettings])
def results2 = Tweet.search("${params.query}", [highlight: highlightSettings2])

def highlightSettings = {
    field 'message'
    preTags '<myAweSomeTag>'
    postTags '</myAweSomeTag>'
}

elasticSearchService.index(domain)
// Some code…
// …
elasticSearchService.index(domain2)
// Some code…
// …
elasticSearchService.index(domain3)
// Some code…
// …
elasticSearchAdminService.refresh() // Ensure that the 3 previous index requests have been made searchable by ES

elasticSearchAdminService.deleteIndex()

class MySearchService {
    static transactional = true
    def elasticSearchHelper
    def myMethod(indexName, settings) {
        elasticSearchHelper.withElasticSearch { client ->
            // Do some stuff with the ElasticSearch client
            client.admin()
                .indices()
                .prepareCreate(indexName)
                .setSettings(settings)
                .execute()
                .actionGet()
        }
    }
}

class Tweet {
  static searchable = {
    message boost:2.0
  }
  static belongsTo = [
          user:User
  ]
  static hasMany = [
          tags:Tag
  ]
  static constraints = {
    tags nullable:true, cascade:'save, update'
  }
  String message = ''
  Date dateCreated = new Date()
}

class User {
  static searchable = {
    except = 'password'
    lastname boost:20
    firstname boost:15, index:'not_analyzed'
    listOfThings index:'no'
    someThings index:'no'
    tweets component:true
  }
  static constraints = {
    tweets cascade:'all'
  }
  static hasMany = [
          tweets:Tweet
  ]
  static mappedBy = [
          tweets:'user'
  ]
  String lastname
  String firstname
  String password
  String activity = 'Evildoer'
  String someThings = 'something'
  ArrayList<String> listOfThings = ['this', 'that', 'andthis']
}

class Tag {
  static searchable = {
    except=['boostValue']
  }
  String name
  Integer boostValue = 1
}

class ElasticSearchController {
  def elasticSearchService
  def testCaseService
  def postTweet = {
    if(!params.user?.id) {
      flash.notice = "No user selected."
      redirect(action: 'index')
      return
    }
    User u = User.get(params.user.id)
    if (!u) {
      flash.notice = "User not found"
      redirect(action: 'index')
      return
    }
    // Create tweet
    testCaseService.addTweet(params.tweet?.message, u, params.tags)
    flash.notice = "Tweet posted"
    redirect(action: 'index')
  }
}

def searchForUserTweets = {
    def tweets = Tweet.search("${params.message.search}").searchResults
    def tweetsMsg = 'Messages : '
    tweets.each {
      tweetsMsg += "<br />Tweet from ${it.user?.firstname} ${it.user?.lastname} : ${it.message} "
      tweetsMsg += "(tags : ${it.tags?.collect{t -> t.name}})"
    }
    flash.notice = tweetsMsg
    redirect(action: 'index')
}

def searchAll = {
    def res = elasticSearchService.search("${params.query}").searchResults
    def resMsg = '<strong>Global search result(s):</strong><br />'
    res.each {
      switch(it){
        case Tag:
          resMsg += "<strong>Tag</strong> ${it.name}<br />"
          break
        case Tweet:
          resMsg += "<strong>Tweet</strong> "${it.message}" from ${it.user.firstname} ${it.user.lastname}<br />"
          break
        case User:
          resMsg += "<strong>User</strong> ${it.firstname} ${it.lastname}<br />"
          break
        default:
          resMsg += "<strong>Other</strong> ${it}<br />"
          break
      }
    }
    flash.notice = resMsg
    redirect(action:'index')
 }