Add DriverRoute trait and clean up DriverApp

1 files changed, 84 insertions, 0 deletions

diff --git a/src/main/scala/xyz/driver/core/rest/DriverRoute.scala b/src/main/scala/xyz/driver/core/rest/DriverRoute.scala
new file mode 100644
index 0000000..20cc556
--- /dev/null
+++ b/src/main/scala/xyz/driver/core/rest/DriverRoute.scala
@@ -0,0 +1,84 @@
+package xyz.driver.core.rest
+
+import java.sql.SQLException
+
+import akka.http.scaladsl.model._
+import akka.http.scaladsl.model.StatusCodes.{BadRequest, Conflict, InternalServerError}
+import akka.http.scaladsl.model.headers._
+import akka.http.scaladsl.server.Directives._
+import akka.http.scaladsl.server.{ExceptionHandler, RequestContext, Route}
+import com.typesafe.scalalogging.Logger
+import org.slf4j.MDC
+import xyz.driver.core.rest
+import xyz.driver.core.rest.errors.APIError
+
+import scala.compat.Platform.ConcurrentModificationException
+
+trait DriverRoute {
+  val log: Logger
+
+  def route: Route
+
+  def routeWithDefaults: Route = handleExceptions(ExceptionHandler(exceptionHandler)) {
+    route
+  }
+
+  /**
+    * Override me for custom exception handling
+    *
+    * @return Exception handling route for exception type
+    */
+  protected def exceptionHandler: PartialFunction[Throwable, Route] = {
+    case api: APIError if api.isPatientSensitive =>
+      ctx =>
+        log.info("PHI Sensitive error")
+        errorResponse(ctx, InternalServerError, "Server error", api)(ctx)
+
+    case api: APIError =>
+      ctx =>
+        log.info("API Error")
+        errorResponse(ctx, api.statusCode, api.message, api)(ctx)
+
+    case is: IllegalStateException =>
+      ctx =>
+        log.warn(s"Request is not allowed to ${ctx.request.method} ${ctx.request.uri}", is)
+        errorResponse(ctx, 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, 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, InternalServerError, "Data access error", se)(ctx)
+
+    case t: Throwable =>
+      ctx =>
+        log.warn(s"Request to ${ctx.request.method} ${ctx.request.uri} could not be handled normally", t)
+        errorResponse(ctx, InternalServerError, t.getMessage, t)(ctx)
+  }
+
+  protected def errorResponse[T <: Throwable](ctx: RequestContext,
+                                              statusCode: StatusCode,
+                                              message: String,
+                                              exception: T): Route = {
+
+    val trackingId    = rest.extractTrackingId(ctx.request)
+    val tracingHeader = RawHeader(ContextHeaders.TrackingIdHeader, rest.extractTrackingId(ctx.request))
+
+    MDC.put("trackingId", trackingId)
+
+    optionalHeaderValueByType[Origin](()) { originHeader =>
+      val responseHeaders = List[HttpHeader](tracingHeader,
+                                             allowOrigin(originHeader),
+                                             `Access-Control-Allow-Headers`(AllowedHeaders: _*),
+                                             `Access-Control-Expose-Headers`(AllowedHeaders: _*))
+
+      respondWithHeaders(responseHeaders) {
+        complete(HttpResponse(statusCode, entity = message))
+      }
+    }
+  }
+}