com.sksamuel.elastic4s.handlers.index.mapping.MappingHandlers.scala Maven / Gradle / Ivy

Go to download
package com.sksamuel.elastic4s.handlers.index.mapping

import com.sksamuel.elastic4s.handlers.ElasticErrorParser
import com.sksamuel.elastic4s.requests.indexes.{FieldMapping, IndexFieldMapping, IndexMappings, PutMappingResponse}
import com.sksamuel.elastic4s.requests.mappings.{GetFieldMappingRequest, GetMappingRequest, PutMappingRequest}
import com.sksamuel.elastic4s.{
  ElasticError,
  ElasticRequest,
  Handler,
  HttpEntity,
  HttpResponse,
  Indexes,
  ResponseHandler
}

trait MappingHandlers {

  implicit object GetMappingHandler extends Handler[GetMappingRequest, Seq[IndexMappings]] {

    override def responseHandler: ResponseHandler[Seq[IndexMappings]] = new ResponseHandler[Seq[IndexMappings]] {

      override def handle(response: HttpResponse): Either[ElasticError, Seq[IndexMappings]] =
        response.statusCode match {
          case 201 | 200 =>
            val raw  = ResponseHandler.fromResponse[Map[String, Map[String, Map[String, Any]]]](response)
            val raw2 = raw.map {
              case (index, types) =>
                val properties = types("mappings").getOrElse("properties", Map.empty)
                val meta       = types("mappings").getOrElse("_meta", Map.empty)
                IndexMappings(index, properties.asInstanceOf[Map[String, Any]], meta.asInstanceOf[Map[String, Any]])
            }.toSeq
            Right(raw2)
          case _         =>
            try {
              Left(ElasticErrorParser.parse(response))
            } catch {
              case _: Throwable => sys.error(s"""Failed to parse error response: \n${response.toString}""")
            }
        }
    }

    override def build(request: GetMappingRequest): ElasticRequest = {
      val endpoint = request.indexes match {
        case Indexes(Nil)     => "/_mapping"
        case Indexes(indexes) => s"/${indexes.mkString(",")}/_mapping"
      }

      ElasticRequest("GET", endpoint)
    }
  }

  implicit object GetFieldMappingRequest extends Handler[GetFieldMappingRequest, Seq[IndexFieldMapping]] {
    override def responseHandler: ResponseHandler[Seq[IndexFieldMapping]] =
      new ResponseHandler[Seq[IndexFieldMapping]] {

        override def handle(response: HttpResponse): Either[ElasticError, Seq[IndexFieldMapping]] =
          response.statusCode match {
            case 201 | 200 =>
              val raw = ResponseHandler.fromResponse[Map[String, Map[String, Map[String, Map[String, Any]]]]](response)
              Right(raw.map {
                case (index, types) =>
                  val mappings = types("mappings").map {
                    case (_, mapping) =>
                      FieldMapping(mapping("full_name").toString, mapping("mapping").asInstanceOf[Map[String, Any]])
                  }.toSeq
                  IndexFieldMapping(index, mappings)
              }.toSeq)
            case _         =>
              try {
                Left(ElasticErrorParser.parse(response))
              } catch {
                case _: Throwable => sys.error(s"""Failed to parse error response: \n${response.toString}""")
              }
          }
      }

    override def build(request: GetFieldMappingRequest): ElasticRequest = {
      val baseEndpoint = request.indexes match {
        case Indexes(Nil)     => "/_mapping"
        case Indexes(indexes) => s"/${indexes.mkString(",")}/_mapping"
      }

      val endpoint = request.fields match {
        case Nil                 =>
          throw new IllegalArgumentException("Empty fields in GetFieldMappingRequest. Use GetMappingRequest instead.")
        case fields: Seq[String] => s"$baseEndpoint/field/${fields.mkString(",")}"
      }

      ElasticRequest("GET", endpoint)
    }
  }

  implicit object PutMappingHandler extends Handler[PutMappingRequest, PutMappingResponse] {

    override def build(request: PutMappingRequest): ElasticRequest = {

      val endpoint = s"/${request.indexes.values.mkString(",")}/_mapping"

      val params = scala.collection.mutable.Map.empty[String, Any]
      request.updateAllTypes.foreach(params.put("update_all_types", _))
      request.ignoreUnavailable.foreach(params.put("ignore_unavailable", _))
      request.allowNoIndices.foreach(params.put("allow_no_indices", _))
      request.expandWildcards.foreach(params.put("expand_wildcards", _))
      request.includeTypeName.foreach(params.put("include_type_name", _))

      val body   = PutMappingBuilderFn(request).string
      val entity = HttpEntity(body, "application/json")

      ElasticRequest("PUT", endpoint, params.toMap, entity)
    }
  }
}