Merge pull request #72 from delphi-hub/release

Release v1.2.0

Author: bhermann

.travis.yml

@@ -1,11 +1,12 @@
 language: scala
 scala:
-  -  2.12.4
+  -  2.13.1
 script:
   - 'if [ "$TRAVIS_PULL_REQUEST" != "false" ]; then sbt ++$TRAVIS_SCALA_VERSION test; fi'
-  - 'if [ "$TRAVIS_PULL_REQUEST" = "false" ]; then sbt ++$TRAVIS_SCALA_VERSION coverage test coverageReport coverageAggregate codacyCoverage; fi'
+  - 'if [ "$TRAVIS_PULL_REQUEST" = "false" ]; then sbt ++$TRAVIS_SCALA_VERSION test; fi'
+#  - 'if [ "$TRAVIS_PULL_REQUEST" = "false" ]; then sbt ++$TRAVIS_SCALA_VERSION coverage test coverageReport coverageAggregate codacyCoverage; fi'
 after_success:
-  - 'if [ "$TRAVIS_PULL_REQUEST" = "false" ]; then bash <(curl -s https://codecov.io/bash); fi'
+#  - 'if [ "$TRAVIS_PULL_REQUEST" = "false" ]; then bash <(curl -s https://codecov.io/bash); fi'
 cache:
   directories:
     - $HOME/.cache/coursier

app/authorization/AuthProvider.scala

@@ -15,11 +15,15 @@
 // limitations under the License.
 package authorization
 
+import java.time.Clock
+
 import pdi.jwt.{Jwt, JwtAlgorithm, JwtClaim}
 import utils.CommonHelper
 
 object AuthProvider {
 
+  implicit val clock: Clock = Clock.systemUTC
+
   def generateJwt(validFor: Long = 1, useGenericName: Boolean = false): String = {
     val claim = JwtClaim()
       .issuedNow
@@ -32,4 +36,4 @@ object AuthProvider {
     Jwt.encode(claim, CommonHelper.configuration.jwtSecretKey, JwtAlgorithm.HS256)
   }
 
-}
+}

app/controllers/HomeController.scala

@@ -15,25 +15,28 @@
 // limitations under the License.
 package controllers
 
-
+import scala.language.postfixOps
 import java.io.IOException
 
 import akka.actor.ActorSystem
 import akka.http.scaladsl.Http
 import akka.http.scaladsl.model._
 import akka.http.scaladsl.marshalling.Marshal
 import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport
+import akka.http.scaladsl.unmarshalling.Unmarshal
 import akka.stream.ActorMaterializer
 import akka.util.ByteString
 import javax.inject._
 import play.api.Configuration
 import play.api.mvc._
 import utils.CommonHelper
-import org.parboiled2.ParseError
-import de.upb.cs.swt.delphi.core.ql.Syntax
+import models.{InternalFeature, QueryRequestBody}
+import org.parboiled2.{ErrorFormatter, ParseError}
+import de.upb.cs.swt.delphi.core.ql
 
 import scala.util.{Failure, Success, Try}
-import de.upb.cs.swt.delphi.core.ql
+import de.upb.cs.swt.delphi.core.ql._
+import play.api.libs.json._
 
 import scala.concurrent.{Await, Future}
 import spray.json.DefaultJsonProtocol
@@ -47,6 +50,7 @@ import scala.concurrent.duration._
 class HomeController @Inject()(assets: Assets,configuration: Configuration, cc: ControllerComponents) extends AbstractController(cc)
   with SprayJsonSupport with DefaultJsonProtocol {
 
+  var featureList: List[InternalFeature] = List[InternalFeature]()
   /**
     * Create an Action to render an HTML page with a welcome message.
     * The configuration in the `routes` file means that this method
@@ -61,47 +65,87 @@ class HomeController @Inject()(assets: Assets,configuration: Configuration, cc:
     * @return
     */
 
-  def query(query: String): Action[AnyContent] = Action.async {
+  def search: Action[AnyContent] = Action.async {
     implicit request => {
-
-      implicit val system = ActorSystem()
-      implicit val ec = system.dispatcher
-      implicit val materializer = ActorMaterializer()
-      implicit val queryFormat = jsonFormat2(Query)
-
-      val parser = new Syntax(query)
-      val parsingResult: Try[ql.Query] = parser.QueryRule.run()
-      parsingResult match {
-        case Success(_) =>
-          val baseUri = Uri(CommonHelper.getDelphiServer())
-          val prettyParam = Map("pretty" -> "")
-          val searchUri = baseUri.withPath(baseUri.path + "/search").withQuery(akka.http.scaladsl.model.Uri.Query(prettyParam))
-          val responseFuture = Marshal(Query(query, CommonHelper.limit)).to[RequestEntity] flatMap { entity =>
-            Http().singleRequest(HttpRequest(uri = searchUri, method = HttpMethods.POST, entity = entity))
-          }
-          val response = Await.result(responseFuture, 10 seconds)
-          val resultFuture: Future[String] = response match {
-            case HttpResponse(StatusCodes.OK, headers, entity, _) =>
-              entity.dataBytes.runFold(ByteString(""))(_ ++ _).map { body =>
-                body.utf8String
-              }
-            case resp@HttpResponse(code, _, _, _) => {
-              resp.discardEntityBytes()
-              //Future("")
-              Future.failed(throw new IOException(code.defaultMessage()))
+      val jsonBody: Option[JsValue]  = Some(request.body.asJson.get)
+      val jsonEmptyBody = Json.toJson(QueryRequestBody("",Some(0)))
+      val json : JsValue = jsonBody.getOrElse(jsonEmptyBody)
+      val query = json.as[QueryRequestBody]
+
+      val resultLimit = query.limit.getOrElse(CommonHelper.defaultFetchSize)
+      if (resultLimit <= CommonHelper.maxFetchSize) {
+        val parser = new Syntax(query.query)
+        val parsingResult: Try[ql.Query] = parser.QueryRule.run()
+        parsingResult match {
+          case Success(parsedQuery) =>
+            val invalidFields = checkParsedQuery(parsedQuery, query.limit)
+            if (invalidFields.size > 0) {
+            // Future.failed(throw new IllegalArgumentException(s"Unknown field name(s) used. (${invalidFields.mkString(",")})"))
+            Future.successful(new Status(EXPECTATION_FAILED)(s"Incorrect metric name(s) [${invalidFields.mkString(", ")}] entered"))
+            }
+            else{
+              val searchResult = executeQuery(query.query, query.limit)
+              searchResult
             }
+          case Failure(e: ParseError) => {
+            val parserInput = parser.input
+            val formatter = new ErrorFormatter()
+            val parseErrorResponse = JsObject(Seq(
+              "problem" -> JsString(formatter.formatProblem(e, parserInput)),
+              "line" -> JsNumber(e.position.line),
+              "column" -> JsNumber(e.position.column),
+              "query" -> JsString(formatter.formatErrorLine(e, parserInput)),
+              "suggestion" -> JsString(formatter.formatExpected(e))))
+            Future.successful(new Status(UNPROCESSABLE_ENTITY)(parseErrorResponse))
           }
-          val result = Await.result(resultFuture, Duration.Inf)
-          val queryResponse: Future[Result] = Future.successful(Ok(result.toString))
-          queryResponse
+          case Failure(_) =>
+            Future.successful(new Status(EXPECTATION_FAILED)("Search query failed"))
+        }
+      }
+      else {
+        Future.successful(new Status(EXPECTATION_FAILED)(s"Query limit exceeded default limit: ${resultLimit}>${CommonHelper.maxFetchSize}"))
+      }
+    }
+  }
+
+  private def checkParsedQuery(parsedQuery: ql.Query, limit: Option[Int]) : Set[String] = {
+    val fields = collectFieldNames(parsedQuery.expr)
+    val publicFieldNames = featureList.map(i => i.name)
+    val invalidFields = fields.toSet.filter(f => !publicFieldNames.contains(f))
+    invalidFields
+  }
+
+  private def executeQuery(query: String, limit: Option[Int]) :Future[Result] = {
 
-        case Failure(e: ParseError) =>
-          val errorResponse: Future[Result] = Future.successful(new Status(EXPECTATION_FAILED)(parser.formatError(e)))
-          errorResponse
+    implicit val system = ActorSystem()
+    implicit val ec = system.dispatcher
+    implicit val materializer = ActorMaterializer()
+    implicit val queryFormat = jsonFormat2(Query)
+
+    val baseUri = Uri(CommonHelper.getDelphiServer)
+    val prettyParam = Map("pretty" -> "")
+    val searchUri = baseUri.withPath(baseUri.path + "/search").withQuery(akka.http.scaladsl.model.Uri.Query(prettyParam))
+    val responseFuture = Marshal(Query(query, limit)).to[RequestEntity] flatMap { entity =>
+      Http().singleRequest(HttpRequest(uri = searchUri, method = HttpMethods.POST, entity = entity))
+    }
+    val response = Await.result(responseFuture, 10 seconds)
+    val resultFuture: Future[String] = response match {
+
+      case HttpResponse(StatusCodes.OK, headers, entity, _) =>
+        entity.dataBytes.runFold(ByteString(""))(_ ++ _).map { body =>
+          body.utf8String
+        }
+      case resp@HttpResponse(code, _, _, _) => {
+        resp.discardEntityBytes()
+        Future.failed(throw new IOException(code.defaultMessage()))
       }
     }
+    val result = Await.result(resultFuture, Duration.Inf)
+    val queryResponse: Future[Result] = Future.successful(Ok(result.toString))
+    queryResponse
   }
 
+
   /**
     * Get list of features
     *
@@ -114,14 +158,11 @@ class HomeController @Inject()(assets: Assets,configuration: Configuration, cc:
       implicit val system = ActorSystem()
       implicit val ec = system.dispatcher
       implicit val materializer = ActorMaterializer()
+      implicit val queryFormat = jsonFormat2(InternalFeature)
 
       val featuresUri = CommonHelper.getDelphiServer() + "/features"
-
       val responseFuture: Future[HttpResponse] = Http().singleRequest(HttpRequest(uri = featuresUri, method = HttpMethods.GET))
-
-
       val response = Await.result(responseFuture, 10 seconds)
-
       val resultFuture: Future[String] = response match {
         case HttpResponse(StatusCodes.OK, headers, entity, _) =>
           entity.dataBytes.runFold(ByteString(""))(_ ++ _).map { body =>
@@ -132,8 +173,9 @@ class HomeController @Inject()(assets: Assets,configuration: Configuration, cc:
           Future.failed(throw new IOException(code.defaultMessage()))
         }
       }
-
       val result = Await.result(resultFuture, Duration.Inf)
+      val featureListFuture = Unmarshal(result).to[List[InternalFeature]]
+      featureList = Await.result(featureListFuture, Duration.Inf)
       val queryResponse: Future[Result] = Future.successful(Ok(result))
       queryResponse
     }
@@ -150,30 +192,52 @@ class HomeController @Inject()(assets: Assets,configuration: Configuration, cc:
       implicit val ec = system.dispatcher
       implicit val materializer = ActorMaterializer()
 
-      val retrieveUri = CommonHelper.getDelphiServer() + "/retrieve/" + elementId
-      val responseRetrieve: Future[HttpResponse] = Http().singleRequest(HttpRequest(uri = retrieveUri, method = HttpMethods.GET))
+      val splitString: Array[String] = elementId.split(':')
+      if (splitString.length < 2 || splitString.length > 3) {
+        Future.successful(new Status(EXPECTATION_FAILED)(s"Incorrect maven identifier format"))
+      }
+      else {
+        val retrieveUri = CommonHelper.getDelphiServer() + "/retrieve/" + elementId
+        val responseRetrieve: Future[HttpResponse] = Http().singleRequest(HttpRequest(uri = retrieveUri, method = HttpMethods.GET))
 
-      val response = Await.result(responseRetrieve, 10 seconds)
+        val response = Await.result(responseRetrieve, 10 seconds)
 
-      val resultFuture: Future[String] = response match {
-        case HttpResponse(StatusCodes.OK, headers, entity, _) =>
-          entity.dataBytes.runFold(ByteString(""))(_ ++ _).map { body =>
-            body.utf8String
+        val resultFuture: Future[String] = response match {
+          case HttpResponse(StatusCodes.OK, headers, entity, _) =>
+            entity.dataBytes.runFold(ByteString(""))(_ ++ _).map { body =>
+              body.utf8String
+            }
+          case resp@HttpResponse(code, _, _, _) => {
+            resp.discardEntityBytes()
+            Future.failed(throw new IOException(code.defaultMessage()))
           }
-        case resp@HttpResponse(code, _, _, _) => {
-          resp.discardEntityBytes()
-          Future.failed(throw new IOException(code.defaultMessage()))
         }
+
+        val result = Await.result(resultFuture, Duration.Inf)
+        val retrieveResponse: Future[Result] = Future.successful(Ok(result))
+        retrieveResponse
       }
+    }
+  }
 
-      val result = Await.result(resultFuture, Duration.Inf)
-      val retrieveResponse: Future[Result] = Future.successful(Ok(result))
-      retrieveResponse
+  private def collectFieldNames(node: CombinatorialExpr): Seq[String] = {
+    node match {
+      case AndExpr(left, right) => collectFieldNames(left) ++ collectFieldNames(right)
+      case OrExpr(left, right) => collectFieldNames(left) ++ collectFieldNames(right)
+      case NotExpr(expr) => collectFieldNames(expr)
+      case XorExpr(left, right) => collectFieldNames(left) ++ collectFieldNames(right)
+      case EqualExpr(field, _) => Seq(field.fieldName)
+      case NotEqualExpr(field, _) => Seq(field.fieldName)
+      case GreaterThanExpr(field, _) => Seq(field.fieldName)
+      case GreaterOrEqualExpr(field, _) => Seq(field.fieldName)
+      case LessThanExpr(field, _) => Seq(field.fieldName)
+      case LessOrEqualExpr(field, _) => Seq(field.fieldName)
+      case LikeExpr(field, _) => Seq(field.fieldName)
+      case IsTrueExpr(field) => Seq(field.fieldName)
+      case FieldReference(name) => Seq(name)
+      case _ => Seq()
     }
   }
 
-  case class Query(query: String, limit: Option[Int] = None)
+  case class Query(query: String, limit: Option[Int] = Some(CommonHelper.defaultFetchSize))
 }
-
-
-

app/models/QueryFormat.scala renamed to app/models/InternalFeature.scala

@@ -15,10 +15,10 @@
 // limitations under the License.
 package models
 
-import play.api.libs.json.Json
+import spray.json.DefaultJsonProtocol
 
-case class QueryFormat(query:String)
+case class InternalFeature(name : String, description : String)
 
-object QueryFormat {
-  implicit val writes = Json.writes[QueryFormat]
+object InternalFeatureJson extends DefaultJsonProtocol {
+  implicit val featureFormat = jsonFormat2(InternalFeature)
 }

app/models/QueryRequestBody.scala

@@ -0,0 +1,40 @@
+// Copyright (C) 2018 The Delphi Team.
+// See the LICENCE file distributed with this work for additional
+// information regarding copyright ownership.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package models
+
+import play.api.libs.json._
+import utils.CommonHelper
+
+case class QueryRequestBody (query : String, limit : Option[Int] = Some(CommonHelper.defaultFetchSize))
+
+object QueryRequestBody {
+
+  implicit object QueryRequestBodyFormat extends Format[QueryRequestBody] {
+
+    implicit def reads(json: JsValue): JsResult[QueryRequestBody] = {
+      val query = (json \ "query").as[String]
+      val limit : Option[Int] = (json \ "limit").asOpt[Int]
+      JsSuccess(QueryRequestBody(query, limit))
+    }
+
+    def writes(q: QueryRequestBody): JsValue = {
+      val limit = q.limit.getOrElse(CommonHelper.defaultFetchSize)
+      val reqBody = Seq("query" -> JsString(q.query),
+        "limit" -> JsNumber(limit))
+      JsObject(reqBody)
+    }
+  }
+}