adding play2 with slick and flyway

Author: patsta32

.DS_Store

@@ -1,2 +1,41 @@
-*.class
-*.log
+/.idea
+
+modules/play/logs/
+
+# sbt specific
+.cache
+.history
+.lib/
+dist/*
+target/
+lib_managed/
+src_managed/
+project/boot/
+project/plugins/project/
+
+# Scala-IDE specific
+.scala_dependencies
+.worksheet
+
+### PlayFramework template
+# Ignore Play! working directory #
+bin/
+/db
+.eclipse
+/lib/
+/logs/
+/project/project
+/project/target
+/target
+tmp/
+test-result
+server.pid
+*.iml
+*.eml
+/dist/
+
+
+test.mv.db
+
+#Firebase
+firebase.json

.gitignore

@@ -1,2 +1,55 @@
-# bootstrap-play2
-Bootstrap a REST Service with Play 2 Framework
+# Play2-Bootstrap
+
+[![codecov.io](https://img.shields.io/codecov/c/github/innFactory/bootstrap-akka-http/master.svg?style=flat)](https://codecov.io/github/innFactory/bootstrap-akka-http)
+
+Bootstrap a rest service with Play2, isolated Slick and isolated Flyway
+
+This project is built with:
+   - Play Framework 2.6
+   - Slick 3.2.3
+   - Flyway 5.1.1
+   
+   It needs a PostgresQL database
+
+
+## Database Migration
+
+```bash
+sbt flyway/flywayMigrate
+```
+
+## Slick Code Generation
+
+You will need to run the flywayMigrate task first, and then you will be able to generate tables using sbt-codegen.
+
+```bash
+sbt slickGen
+```
+
+## Testing
+
+You can run functional tests against an in memory database and Slick easily with Play from a clean slate:
+
+```bash
+sbt ciTest
+```
+
+## Running
+
+To run the project, start up Play:
+
+```bash
+sbt run
+```
+
+## Running
+
+To create a docker Container:
+
+```bash
+sbt docker:publishLocal
+```
+
+And that's it!
+
+Its locally aviable at: <http://localhost:9000>

LICENSE

@@ -0,0 +1,58 @@
+
+import javax.inject.{Inject, Provider, Singleton}
+import com.google.inject.AbstractModule
+import com.typesafe.config.Config
+import common.jwt.FirebaseJWTValidator
+import models.db._
+import play.api.inject.ApplicationLifecycle
+import play.api.{Configuration, Environment}
+import slick.jdbc.JdbcBackend.Database
+
+import scala.concurrent.Future
+
+/**
+ * This module handles the bindings for the API to the Slick implementation.
+ *
+ * https://www.playframework.com/documentation/latest/ScalaDependencyInjection#Programmatic-bindings
+ */
+class Module(environment: Environment,
+             configuration: Configuration) extends AbstractModule {
+  override def configure(): Unit = {
+    bind(classOf[Database]).toProvider(classOf[DatabaseProvider])
+    bind(classOf[ContactDAO]).to(classOf[SlickContactDAO])
+    bind(classOf[ContactDAOCloseHook]).asEagerSingleton()
+    bind(classOf[firebaseCreationService]).asEagerSingleton()
+    bind(classOf[firebaseDeletionService]).asEagerSingleton()
+    bind(classOf[configuration]).asEagerSingleton()
+  }
+}
+
+class configuration @Inject() (config: Config) {
+  config
+}
+
+/** Creates FirebaseApp on Application creation */
+class firebaseCreationService @Inject() (config: Config) {
+  FirebaseJWTValidator.instanciateFirebase(config.getString("firebase.file"), "https://innfactory-inntend.firebaseio.com/")
+}
+
+/** Deletes FirebaseApp safely. Important on dev restart. */
+class firebaseDeletionService @Inject()(lifecycle: ApplicationLifecycle) {
+  lifecycle.addStopHook { () =>
+    Future.successful(FirebaseJWTValidator.deleteFirebase())
+  }
+}
+
+@Singleton
+class DatabaseProvider @Inject() (config: Config) extends Provider[Database] {
+  lazy val get = Database.forConfig("innSide.database", config)
+}
+
+/** Closes database connections safely.  Important on dev restart. */
+class ContactDAOCloseHook @Inject()(dao: ContactDAO, lifecycle: ApplicationLifecycle) {
+  lifecycle.addStopHook { () =>
+    Future.successful(dao.close())
+  }
+}
+
+

README.md

@@ -0,0 +1,23 @@
+package common.errorHandling
+
+import play.api.http.HttpErrorHandler
+import play.api.mvc._
+import play.api.mvc.Results._
+import scala.concurrent._
+import javax.inject.Singleton
+
+@Singleton
+class ErrorHandler extends HttpErrorHandler {
+
+  def onClientError(request: RequestHeader, statusCode: Int, message: String) = {
+    Future.successful(
+      Status(statusCode)("A client error occurred: " + message)
+    )
+  }
+
+  def onServerError(request: RequestHeader, exception: Throwable) = {
+    Future.successful(
+      InternalServerError("A server error occurred: " + exception.getMessage)
+    )
+  }
+}

app/.DS_Store

@@ -0,0 +1,40 @@
+package common.jwt
+import com.google.auth.oauth2.GoogleCredentials
+import com.google.firebase.auth.{FirebaseAuth, FirebaseToken}
+import com.google.firebase.{FirebaseApp, FirebaseOptions}
+import com.nimbusds.jwt.proc.BadJWTException
+
+import scala.util.{Failure, Success, Try}
+
+object FirebaseJWTValidator {
+
+  def instanciateFirebase(jsonFilePath: String, databseUrl: String) = {
+    val serviceAccount =
+      getClass().getClassLoader().getResourceAsStream(jsonFilePath)
+
+    val options: FirebaseOptions = new FirebaseOptions.Builder()
+      .setCredentials(GoogleCredentials.fromStream(serviceAccount))
+      .setDatabaseUrl(databseUrl)
+      .build
+    FirebaseApp.initializeApp(options)
+  }
+
+  def deleteFirebase(): Unit = {
+    FirebaseApp.getInstance().delete()
+  }
+
+  def apply(): FirebaseJWTValidator = new FirebaseJWTValidator()
+}
+
+class FirebaseJWTValidator extends JwtValidator[FirebaseToken] {
+
+  override def validate(
+                         jwtToken: JwtToken): Either[BadJWTException, FirebaseToken] = {
+    val decodedToken = Try(
+      FirebaseAuth.getInstance.verifyIdToken(jwtToken.content))
+    decodedToken match {
+      case Success(dt) => Right(dt)
+      case Failure(f)  => Left(new BadJWTException(f.getMessage, f))
+    }
+  }
+}

app/Module.scala

@@ -0,0 +1,36 @@
+package common.jwt
+
+import akka.stream.Materializer
+import com.nimbusds.jwt.proc.BadJWTException
+import javax.inject.Inject
+import play.api.mvc.Results.Unauthorized
+import play.api.mvc._
+
+import scala.concurrent.{ExecutionContext, Future}
+
+class JwtFilter @Inject() (implicit val mat: Materializer, ec: ExecutionContext) extends Filter {
+  def apply(nextFilter: RequestHeader => Future[Result])
+           (requestHeader: RequestHeader): Future[Result] = {
+    if(sys.env.getOrElse("SWAGGER_AUTH", "EXPOSE_SWAGGER") == "EXPOSE_SWAGGER" && requestHeader.path == "/v1/swagger.json") {
+      nextFilter.apply(requestHeader)
+    } else {
+      requestHeader.headers.get("Authorization") match {
+        case Some(header) =>{
+
+          val token = header match {
+            case x : String if x.startsWith("Bearer") => JwtToken(x.splitAt(7)._2)
+            case x => JwtToken(x)
+          }
+          FirebaseJWTValidator.apply().validate(token) match {
+            case Left(error: BadJWTException) => Future(Unauthorized(error.getMessage))
+            case Right(dt) => nextFilter.apply(requestHeader)
+          }
+        }
+        case None => Future.successful(
+          Unauthorized("No authorization header present")
+        )
+      }
+    }
+
+  }
+}

app/common/.DS_Store

@@ -0,0 +1,27 @@
+package common.jwt
+
+import com.nimbusds.jwt.JWTClaimsSet
+import com.nimbusds.jwt.proc.BadJWTException
+
+final case class JwtToken(content: String) extends AnyVal
+
+sealed abstract class ValidationError(message: String)
+  extends BadJWTException(message)
+case object EmptyJwtTokenContent extends ValidationError("Empty JWT token")
+case object AutoInvalidByValidator extends ValidationError("auto-invalid")
+case object InvalidJwtToken extends ValidationError("Invalid JWT token")
+case object MissingExpirationClaim
+  extends ValidationError("Missing `exp` claim")
+case object InvalidTokenUseClaim
+  extends ValidationError("Invalid `token_use` claim")
+case object InvalidTokenIssuerClaim
+  extends ValidationError("Invalid `iss` claim")
+case object InvalidTokenSubject extends ValidationError("Invalid `sub` claim")
+case class UnknownException(exception: Exception)
+  extends ValidationError("Unknown JWT validation error")
+
+case class DefaultAuthResult(token: JwtToken, jwtClaimSet: JWTClaimsSet)
+
+trait JwtValidator[T] {
+  def validate(jwtToken: JwtToken): Either[BadJWTException, T]
+}

app/common/errorHandling/ErrorHandler.scala

@@ -0,0 +1,12 @@
+package common.messages
+
+object SlickIO {
+  abstract class Error(message: String, statusCode: Int)
+
+  case class SuccessWithStatusCode[T](body: T, status: Int)
+
+  case class DatabaseError(message: String, statusCode: Int) extends Error(message = message, statusCode = statusCode)
+
+  type Result[T] = Either[Error, T]
+
+}