Merge branch 'master' into kseniya/typized-idkseniya/typized-id

1 files changed, 0 insertions, 122 deletions

diff --git a/src/main/scala/xyz/driver/core/rest/DriverRoute.scala b/src/main/scala/xyz/driver/core/rest/DriverRoute.scala
deleted file mode 100644
index 911e306..0000000
--- a/src/main/scala/xyz/driver/core/rest/DriverRoute.scala
+++ /dev/null
@@ -1,122 +0,0 @@
-package xyz.driver.core.rest
-
-import java.sql.SQLException
-
-import akka.http.scaladsl.model.headers.CacheDirectives.`no-cache`
-import akka.http.scaladsl.model.headers._
-import akka.http.scaladsl.model.{StatusCodes, _}
-import akka.http.scaladsl.server.Directives._
-import akka.http.scaladsl.server._
-import com.typesafe.scalalogging.Logger
-import org.slf4j.MDC
-import xyz.driver.core.rest
-import xyz.driver.core.rest.errors._
-
-import scala.compat.Platform.ConcurrentModificationException
-
-trait DriverRoute {
-  def log: Logger
-
-  def route: Route
-
-  def routeWithDefaults: Route = {
-    (defaultResponseHeaders & handleExceptions(ExceptionHandler(exceptionHandler))) {
-      route
-    }
-  }
-
-  protected def defaultResponseHeaders: Directive0 = {
-    extractRequest flatMap { 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)
-
-      respondWithHeaders(tracingHeader +: DriverRoute.DefaultHeaders: _*)
-    }
-  }
-
-  /**
-    * Override me for custom exception handling
-    *
-    * @return Exception handling route for exception type
-    */
-  protected def exceptionHandler: PartialFunction[Throwable, Route] = {
-    case serviceException: ServiceException =>
-      serviceExceptionHandler(serviceException)
-
-    case is: IllegalStateException =>
-      ctx =>
-        log.warn(s"Request is not allowed to ${ctx.request.method} ${ctx.request.uri}", is)
-        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(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(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(StatusCodes.InternalServerError, t.getMessage, t)(ctx)
-  }
-
-  protected def serviceExceptionHandler(serviceException: ServiceException): Route = {
-    val statusCode = serviceException match {
-      case e: InvalidInputException =>
-        log.info("Invalid client input error", e)
-        StatusCodes.BadRequest
-      case e: InvalidActionException =>
-        log.info("Invalid client action error", e)
-        StatusCodes.Forbidden
-      case e: UnauthorizedException =>
-        log.info("Unauthorized user error", e)
-        StatusCodes.Unauthorized
-      case e: ResourceNotFoundException =>
-        log.info("Resource not found error", e)
-        StatusCodes.NotFound
-      case e: ExternalServiceException =>
-        log.error("Error while calling another service", e)
-        StatusCodes.InternalServerError
-      case e: ExternalServiceTimeoutException =>
-        log.error("Service timeout error", e)
-        StatusCodes.GatewayTimeout
-      case e: DatabaseException =>
-        log.error("Database error", e)
-        StatusCodes.InternalServerError
-    }
-
-    { (ctx: RequestContext) =>
-      import xyz.driver.core.json.serviceExceptionFormat
-      val entity =
-        HttpEntity(ContentTypes.`application/json`, serviceExceptionFormat.write(serviceException).toString())
-      errorResponse(statusCode, entity, serviceException)(ctx)
-    }
-  }
-
-  protected def errorResponse[T <: Exception](statusCode: StatusCode, message: String, exception: T): Route =
-    errorResponse(statusCode, HttpEntity(message), exception)
-
-  protected def errorResponse[T <: Exception](statusCode: StatusCode, entity: ResponseEntity, exception: T): Route = {
-    complete(HttpResponse(statusCode, entity = entity))
-  }
-
-}
-
-object DriverRoute {
-  val DefaultHeaders: List[HttpHeader] = List(
-    // This header will eliminate the risk of envoy trying to reuse a connection
-    // that already timed out on the server side by completely rejecting keep-alive
-    Connection("close"),
-    // These 2 headers are the simplest way to prevent IE from caching GET requests
-    RawHeader("Pragma", "no-cache"),
-    `Cache-Control`(List(`no-cache`(Nil)))
-  )
-}