com.sksamuel.elastic4s.requests.script.Script.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of elastic4s-domain_2.12 Show documentation
elastic4s-domain
The newest version!
package com.sksamuel.elastic4s.requests.script

import com.sksamuel.elastic4s.ParamSerializer

import scala.language.implicitConversions

/**
  * A script that can be used in queries (ex: Painless scripting).
  * @param script the script source
  * @param lang the language of the script (defaults to Painless)
  * @param scriptType the type of script (see [[ScriptType.Source]])
  * @param params the parameters of the script which will be automatically-serialized
  * @param options the options for this script
  * @param paramsRaw the parameters of the script which are already serialized
  */
case class Script(script: String,
                  lang: Option[String] = None,
                  scriptType: ScriptType = ScriptType.Source,
                  params: Map[String, Any] = Map.empty,
                  options: Map[String, String] = Map.empty,
                  paramsRaw: Map[String, String] = Map.empty) {

  /**
    * Sets the script language.
    */
  def lang(lang: String): Script                                    = copy(lang = Option(lang))

  /**
    * Sets a parameter that will be automatically-serialized before sending to Elasticsearch.
    * @param name the parameter key
    * @param value the parameter value as a primitive type ([[Double]], [[BigInt]], [[Seq]], [[Map]], etc.);
    *              for all the primitive types supported, see [[com.sksamuel.elastic4s.json.XContentBuilder#autofield]];
    *              for sending objects, see [[paramRaw]] and [[paramObject]]
    */
  def param(name: String, value: Any): Script                       = copy(params = params + (name -> value))
  def params(first: (String, Any), rest: (String, AnyRef)*): Script = params(first +: rest)
  def params(seq: Seq[(String, Any)]): Script                       = params(seq.toMap)
  def params(map: Map[String, Any]): Script                         = copy(params = params ++ map)

  /**
    * Sets an already-serialized parameter.
    * @param name the parameter key
    * @param value the parameter serialized value as a string
    */
  def paramRaw(name: String, value: String): Script                       = copy(paramsRaw = paramsRaw + (name -> value))
  def paramsRaw(first: (String, String), rest: (String, String)*): Script = paramsRaw(first +: rest)
  def paramsRaw(seq: Seq[(String, String)]): Script                       = paramsRaw(seq.toMap)
  def paramsRaw(map: Map[String, String]): Script                         = copy(paramsRaw = paramsRaw ++ map)

  /**
    * Sets a parameter with an object value, which is serialized with the given implicit serializer.
    * @param name the parameter key
    * @param value the parameter value
    * @param serializer the parameter serializer (see [[ParamSerializer]])
    * @tparam T object's type
    */
  def paramObject[T](name: String, value: T)(implicit serializer: ParamSerializer[T]): Script =
    copy(paramsRaw = paramsRaw + (name -> serializer.json(value)))
  def paramsObject[T](first: (String, T), rest: (String, T)*)(implicit serializer: ParamSerializer[T]): Script = paramsObject(first +: rest)
  def paramsObject[T](seq: Seq[(String, T)])(implicit serializer: ParamSerializer[T]): Script                  = paramsObject(seq.toMap)
  def paramsObject[T](map: Map[String, T])(implicit serializer: ParamSerializer[T]): Script =
    copy(paramsRaw = paramsRaw ++ map.mapValues(serializer.json))

  def scriptType(tpe: String): Script            = copy(scriptType = ScriptType.valueOf(tpe))
  def scriptType(scriptType: ScriptType): Script = copy(scriptType = scriptType)
}

object Script {
  implicit def string2Script(script: String): Script = Script(script)
}