Merge branch 'master' into TM-1431

3 files changed, 27 insertions, 25 deletions

diff --git a/src/main/scala/xyz/driver/core/database/Dal.scala b/src/main/scala/xyz/driver/core/database/Dal.scala
index 581bd0f..bcde0de 100644
--- a/src/main/scala/xyz/driver/core/database/Dal.scala
+++ b/src/main/scala/xyz/driver/core/database/Dal.scala
@@ -1,10 +1,11 @@
 package xyz.driver.core.database
 
-import slick.lifted.AbstractTable
+import scalaz.std.scalaFuture._
+import scalaz.{ListT, Monad, OptionT}
+import slick.lifted.{AbstractTable, CanBeQueryCondition, RunnableCompiled}
+import slick.{lifted => sl}
 
 import scala.concurrent.{ExecutionContext, Future}
-import scalaz.{ListT, Monad, OptionT}
-import scalaz.std.scalaFuture._
 
 trait Dal {
   type T[D]
@@ -34,16 +35,20 @@ class SlickDal(database: Database, executionContext: ExecutionContext) extends D
 
   override type T[D] = slick.dbio.DBIO[D]
 
-  implicit protected class QueryOps[U](query: Query[_, U, Seq]) {
+  implicit protected class QueryOps[+E, U](query: Query[E, U, Seq]) {
     def resultT: ListT[T, U] = ListT[T, U](query.result.map(_.toList))
+
+    def maybeFilter[V, R: CanBeQueryCondition](data: Option[V])(f: V => E => R): sl.Query[E, U, Seq] =
+      data.map(v => query.withFilter(f(v))).getOrElse(query)
   }
 
-  implicit protected class CompiledQueryOps[U](compiledQuery: slick.lifted.RunnableCompiled[_, Seq[U]]) {
+  implicit protected class CompiledQueryOps[U](compiledQuery: RunnableCompiled[_, Seq[U]]) {
     def resultT: ListT[T, U] = ListT.listT[T](compiledQuery.result.map(_.toList))
   }
 
   private val dbioMonad = new Monad[T] {
-    override def point[A](a: => A): T[A]                  = DBIO.successful(a)
+    override def point[A](a: => A): T[A] = DBIO.successful(a)
+
     override def bind[A, B](fa: T[A])(f: A => T[B]): T[B] = fa.flatMap(f)
   }
 
@@ -53,7 +58,8 @@ class SlickDal(database: Database, executionContext: ExecutionContext) extends D
     database.database.run(readOperations.transactionally)
   }
 
-  override def noAction[V](v: V): T[V]                     = DBIO.successful(v)
+  override def noAction[V](v: V): T[V] = DBIO.successful(v)
+
   override def customAction[R](action: => Future[R]): T[R] = DBIO.from(action)
 
   def affectsRows(updatesCount: Int): Option[Unit] = {
diff --git a/src/main/scala/xyz/driver/core/rest/DriverRoute.scala b/src/main/scala/xyz/driver/core/rest/DriverRoute.scala
index 674a0c4..c23c44d 100644
--- a/src/main/scala/xyz/driver/core/rest/DriverRoute.scala
+++ b/src/main/scala/xyz/driver/core/rest/DriverRoute.scala
@@ -26,7 +26,12 @@ trait DriverRoute {
 
   protected def defaultResponseHeaders: Directive0 = {
     extractRequest flatMap { request =>
-      val tracingHeader = RawHeader(ContextHeaders.TrackingIdHeader, rest.extractTrackingId(request))
+      // Needs to happen before any request processing, so all the log messages
+      // associated with processing of this request are having this `trackingId`
+      val trackingId    = rest.extractTrackingId(request)
+      val tracingHeader = RawHeader(ContextHeaders.TrackingIdHeader, trackingId)
+      MDC.put("trackingId", trackingId)
+
       respondWithHeader(tracingHeader)
     }
   }
@@ -43,26 +48,23 @@ trait DriverRoute {
     case is: IllegalStateException =>
       ctx =>
         log.warn(s"Request is not allowed to ${ctx.request.method} ${ctx.request.uri}", is)
-        errorResponse(ctx, StatusCodes.BadRequest, message = is.getMessage, is)(ctx)
+        errorResponse(StatusCodes.BadRequest, message = is.getMessage, is)(ctx)
 
     case cm: ConcurrentModificationException =>
       ctx =>
         log.warn(s"Concurrent modification of the resource ${ctx.request.method} ${ctx.request.uri}", cm)
-        errorResponse(
-          ctx,
-          StatusCodes.Conflict,
-          "Resource was changed concurrently, try requesting a newer version",
-          cm)(ctx)
+        errorResponse(StatusCodes.Conflict, "Resource was changed concurrently, try requesting a newer version", cm)(
+          ctx)
 
     case se: SQLException =>
       ctx =>
         log.warn(s"Database exception for the resource ${ctx.request.method} ${ctx.request.uri}", se)
-        errorResponse(ctx, StatusCodes.InternalServerError, "Data access error", se)(ctx)
+        errorResponse(StatusCodes.InternalServerError, "Data access error", se)(ctx)
 
     case t: Exception =>
       ctx =>
         log.warn(s"Request to ${ctx.request.method} ${ctx.request.uri} could not be handled normally", t)
-        errorResponse(ctx, StatusCodes.InternalServerError, t.getMessage, t)(ctx)
+        errorResponse(StatusCodes.InternalServerError, t.getMessage, t)(ctx)
   }
 
   protected def serviceExceptionHandler(serviceException: ServiceException): Route = {
@@ -88,17 +90,11 @@ trait DriverRoute {
     }
 
     { (ctx: RequestContext) =>
-      errorResponse(ctx, statusCode, serviceException.message, serviceException)(ctx)
+      errorResponse(statusCode, serviceException.message, serviceException)(ctx)
     }
   }
 
-  protected def errorResponse[T <: Exception](
-      ctx: RequestContext,
-      statusCode: StatusCode,
-      message: String,
-      exception: T): Route = {
-    val trackingId = rest.extractTrackingId(ctx.request)
-    MDC.put("trackingId", trackingId)
+  protected def errorResponse[T <: Exception](statusCode: StatusCode, message: String, exception: T): Route = {
     complete(HttpResponse(statusCode, entity = message))
   }
 }
diff --git a/src/test/scala/xyz/driver/core/GeneratorsTest.scala b/src/test/scala/xyz/driver/core/GeneratorsTest.scala
index 53a3aa9..7e740a4 100644
--- a/src/test/scala/xyz/driver/core/GeneratorsTest.scala
+++ b/src/test/scala/xyz/driver/core/GeneratorsTest.scala
@@ -38,7 +38,7 @@ class GeneratorsTest extends FlatSpec with Matchers with Assertions {
 
   it should "be able to generate com.drivergrp.core.Name names" in {
 
-    nextName[String]() should not be nextName[String]()
+    Seq.fill(10)(nextName[String]()).distinct.size should be > 1
     nextName[String]().value.length should be >= 0
 
     val fixedLengthName = nextName[String](10)