added analysis section

package controllers

import models.analysis.{IndexAnalyzers, IndexFields, OpenIndices, Tokens}

import models.ElasticServer

import scala.concurrent.ExecutionContext.Implicits.global

class AnalysisController extends BaseController {

  def getIndices = process { (request, client) =>

    client.getIndices(ElasticServer(request.host, request.authentication)).map { response =>

      Status(response.status)(OpenIndices(response.body))

    }

  }

  def getIndexAnalyzers = process { (request, client) =>

    val index = request.get("index")

    client.getIndexSettings(index, ElasticServer(request.host, request.authentication)).map { response =>

       Status(response.status)(IndexAnalyzers(index, response.body))

    }

  }

  def getIndexFields = process { (request, client) =>

    val index = request.get("index")

    client.getIndexMapping(index, ElasticServer(request.host, request.authentication)).map { response =>

      Status(response.status)(IndexFields(index, response.body))

    }

  }

  def analyzeByField = process { (request, client) =>

    val index = request.get("index")

    val field = request.get("field")

    val text = request.get("text")

    client.analyzeTextByField(index, field, text, ElasticServer(request.host, request.authentication)).map { response =>

      Status(response.status)(Tokens(response.body))

    }

  }

  def analyzeByAnalyzer = process { (request, client) =>

    val index = request.get("index")

    val analyzer = request.get("analyzer")

    val text = request.get("text")

    client.analyzeTextByAnalyzer(index, analyzer, text, ElasticServer(request.host, request.authentication)).map { response =>

      Status(response.status)(Tokens(response.body))

    }

  }

}

    execute(s"${target.host}$path", "POST", Some(metadata.toString), target.authentication)

  }

  def getIndices(target: ElasticServer) = {

    val path = s"/_cat/indices?format=json"

    execute(s"${target.host}$path", "GET", None, target.authentication)

  }

  def analyzeTextByField(index: String, field: String, text: String, target: ElasticServer) = {

    val path = s"/$index/_analyze"

    val body = Json.obj("text" -> text, "field" -> field).toString()

    execute(s"${target.host}$path", "GET", Some(body), target.authentication)

  }

  def analyzeTextByAnalyzer(index: String, analyzer: String, text: String, target: ElasticServer) = {

    val path = s"/$index/_analyze"

    val body = Json.obj("text" -> text, "analyzer" -> analyzer).toString()

    execute(s"${target.host}$path", "GET", Some(body), target.authentication)

  }

  def executeRequest(method: String, path: String, data: Option[JsValue], target: ElasticServer) =

    execute(s"${target.host}/$path", method, data.map(_.toString), target.authentication)

package models.analysis

import play.api.libs.json._

object IndexAnalyzers {

  def apply(index: String, mapping: JsValue): JsArray = {

    val analyzers = (mapping \ index \ "settings" \ "index" \ "analysis" \ "analyzer").asOpt[JsObject]

    JsArray(analyzers.map(_.keys.toSeq).getOrElse(Seq()).map(JsString(_)))

  }

}

package models.analysis

import play.api.libs.json._

object IndexFields {

  def apply(index: String, data: JsValue) = {

    val docTypes = (data \ index \ "mappings").as[JsObject].keys

    val fields = docTypes.flatMap { docType =>

      extractProperties((data \ index \ "mappings" \ docType \ "properties").as[JsValue])

    }.toSeq

    JsArray(fields.map(JsString(_)))

  }

  def extractProperties(data: JsValue): Seq[String] = {

    data match {

      case obj: JsObject =>

        obj.keys.collect {

          case p if (data \ p \ "properties").asOpt[JsObject].isDefined =>

            extractProperties((data \ p \ "properties").as[JsValue]).map(s"$p.".concat(_))

          case p if (data \ p \ "fields").asOpt[JsObject].isDefined =>

            val fields = (data \ p \ "fields").as[JsObject].keys.collect {

              case field if (data \ p \ "fields" \ field \ "type").asOpt[String].exists(_.equals("string")) =>

                s"$p.$field"

            }.toSeq

            if ((data \ p \ "type").asOpt[String].exists(_.equals("string"))) {

              fields :+ p

            } else {

              fields

            }

          case p if (data \ p \ "type").asOpt[String].exists(_.equals("string")) =>

            Seq(p)

        }.flatten.toSeq

      case _ => Seq()

    }

  }

}

package models.analysis

import play.api.libs.json.{JsArray, JsString, JsValue}

object OpenIndices {

  def apply(data: JsValue) = JsArray(data.as[JsArray].value.collect {

    case index if (index \ "status").as[String].equals("open") => (index \ "index").as[JsString]

  })

}