Merge branch 'master' into BAEL-16646-2

play-framework/student-api/.gitignore

@@ -0,0 +1,9 @@
+logs
+target
+/.idea
+/.g8
+/.idea_modules
+/.classpath
+/.project
+/.settings
+/RUNNING_PID

play-framework/student-api/app/controllers/StudentController.java

@@ -0,0 +1,91 @@
+package controllers;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import model.Student;
+import play.libs.Json;
+import play.libs.concurrent.HttpExecutionContext;
+import play.mvc.Controller;
+import play.mvc.Http;
+import play.mvc.Result;
+import store.StudentStore;
+import utils.Util;
+
+import javax.inject.Inject;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.CompletionStage;
+
+import static java.util.concurrent.CompletableFuture.supplyAsync;
+
+public class StudentController extends Controller {
+    private HttpExecutionContext ec;
+    private StudentStore studentStore;
+
+    @Inject
+    public StudentController(HttpExecutionContext ec, StudentStore studentStore) {
+        this.studentStore = studentStore;
+        this.ec = ec;
+    }
+
+    public CompletionStage<Result> create(Http.Request request) {
+        JsonNode json = request.body().asJson();
+        return supplyAsync(() -> {
+            if (json == null) {
+                return badRequest(Util.createResponse("Expecting Json data", false));
+            }
+
+            Optional<Student> studentOptional = studentStore.addStudent(Json.fromJson(json, Student.class));
+            return studentOptional.map(student -> {
+                JsonNode jsonObject = Json.toJson(student);
+                return created(Util.createResponse(jsonObject, true));
+            }).orElse(internalServerError(Util.createResponse("Could not create data.", false)));
+        }, ec.current());
+    }
+
+    public CompletionStage<Result> listStudents() {
+        return supplyAsync(() -> {
+            Set<Student> result = studentStore.getAllStudents();
+            ObjectMapper mapper = new ObjectMapper();
+            JsonNode jsonData = mapper.convertValue(result, JsonNode.class);
+            return ok(Util.createResponse(jsonData, true));
+        }, ec.current());
+    }
+
+    public CompletionStage<Result> retrieve(int id) {
+        return supplyAsync(() -> {
+            final Optional<Student> studentOptional = studentStore.getStudent(id);
+            return studentOptional.map(student -> {
+                JsonNode jsonObjects = Json.toJson(student);
+                return ok(Util.createResponse(jsonObjects, true));
+            }).orElse(notFound(Util.createResponse("Student with id:" + id + " not found", false)));
+        }, ec.current());
+    }
+
+    public CompletionStage<Result> update(Http.Request request) {
+        JsonNode json = request.body().asJson();
+        return supplyAsync(() -> {
+            if (json == null) {
+                return badRequest(Util.createResponse("Expecting Json data", false));
+            }
+            Optional<Student> studentOptional = studentStore.updateStudent(Json.fromJson(json, Student.class));
+            return studentOptional.map(student -> {
+                if (student == null) {
+                    return notFound(Util.createResponse("Student not found", false));
+                }
+                JsonNode jsonObject = Json.toJson(student);
+                return ok(Util.createResponse(jsonObject, true));
+            }).orElse(internalServerError(Util.createResponse("Could not create data.", false)));
+        }, ec.current());
+    }
+
+    public CompletionStage<Result> delete(int id) {
+        return supplyAsync(() -> {
+            boolean status = studentStore.deleteStudent(id);
+            if (!status) {
+                return notFound(Util.createResponse("Student with id:" + id + " not found", false));
+            }
+            return ok(Util.createResponse("Student with id:" + id + " deleted", true));
+        }, ec.current());
+    }
+}

play-framework/student-api/app/model/Student.java

@@ -0,0 +1,50 @@
+package model;
+
+public class Student {
+    private String firstName;
+    private String lastName;
+    private int age;
+    private int id;
+
+    public Student() {
+    }
+
+    public Student(String firstName, String lastName, int age, int id) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+        this.age = age;
+        this.id = id;
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+}

play-framework/student-api/app/store/StudentStore.java

@@ -0,0 +1,37 @@
+package store;
+
+import model.Student;
+
+import java.util.*;
+
+public class StudentStore {
+    private Map<Integer, Student> students = new HashMap<>();
+
+    public Optional<Student> addStudent(Student student) {
+        int id = students.size();
+        student.setId(id);
+        students.put(id, student);
+        return Optional.ofNullable(student);
+    }
+
+    public Optional<Student> getStudent(int id) {
+        return Optional.ofNullable(students.get(id));
+    }
+
+    public Set<Student> getAllStudents() {
+        return new HashSet<>(students.values());
+    }
+
+    public Optional<Student> updateStudent(Student student) {
+        int id = student.getId();
+        if (students.containsKey(id)) {
+            students.put(id, student);
+            return Optional.ofNullable(student);
+        }
+        return Optional.empty();
+    }
+
+    public boolean deleteStudent(int id) {
+        return students.remove(id) != null;
+    }
+}

play-framework/student-api/app/utils/Util.java

@@ -0,0 +1,17 @@
+package utils;
+
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import play.libs.Json;
+
+public class Util {
+    public static ObjectNode createResponse(Object response, boolean ok) {
+        ObjectNode result = Json.newObject();
+        result.put("isSuccessful", ok);
+        if (response instanceof String) {
+            result.put("body", (String) response);
+        } else {
+            result.putPOJO("body", response);
+        }
+        return result;
+    }
+}

play-framework/student-api/build.sbt

@@ -0,0 +1,10 @@
+name := """student-api"""
+organization := "com.baeldung"
+
+version := "1.0-SNAPSHOT"
+
+lazy val root = (project in file(".")).enablePlugins(PlayJava)
+
+scalaVersion := "2.13.0"
+
+libraryDependencies += guice

play-framework/student-api/conf/application.conf

@@ -0,0 +1,2 @@
+# This is the main configuration file for the application.
+# https://www.playframework.com/documentation/latest/ConfigFile

play-framework/student-api/conf/logback.xml

@@ -0,0 +1,35 @@
+<!-- https://www.playframework.com/documentation/latest/SettingsLogger -->
+<configuration>
+
+  <conversionRule conversionWord="coloredLevel" converterClass="play.api.libs.logback.ColoredLevel" />
+
+  <appender name="FILE" class="ch.qos.logback.core.FileAppender">
+    <file>${application.home:-.}/logs/application.log</file>
+    <encoder>
+      <pattern>%date [%level] from %logger in %thread - %message%n%xException</pattern>
+    </encoder>
+  </appender>
+
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <encoder>
+      <pattern>%coloredLevel %logger{15} - %message%n%xException{10}</pattern>
+    </encoder>
+  </appender>
+
+  <appender name="ASYNCFILE" class="ch.qos.logback.classic.AsyncAppender">
+    <appender-ref ref="FILE" />
+  </appender>
+
+  <appender name="ASYNCSTDOUT" class="ch.qos.logback.classic.AsyncAppender">
+    <appender-ref ref="STDOUT" />
+  </appender>
+
+  <logger name="play" level="INFO" />
+  <logger name="application" level="DEBUG" />
+
+  <root level="WARN">
+    <appender-ref ref="ASYNCFILE" />
+    <appender-ref ref="ASYNCSTDOUT" />
+  </root>
+
+</configuration>

play-framework/student-api/conf/routes

@@ -0,0 +1,12 @@
+# Routes
+# This file defines all application routes (Higher priority routes first)
+# ~~~~
+
+GET     /                           controllers.StudentController.listStudents()
+GET     /:id                        controllers.StudentController.retrieve(id:Int)
+POST    /                           controllers.StudentController.create(request: Request)
+PUT     /                           controllers.StudentController.update(request: Request)
+DELETE  /:id                        controllers.StudentController.delete(id:Int)
+
+# Map static resources from the /public folder to the /assets URL path
+GET     /assets/*file               controllers.Assets.versioned(path="/public", file: Asset)

play-framework/student-api/project/build.properties

@@ -0,0 +1 @@
+sbt.version=1.2.8

play-framework/student-api/project/plugins.sbt

@@ -0,0 +1,7 @@
+// The Play plugin
+addSbtPlugin("com.typesafe.play" % "sbt-plugin" % "2.7.3")
+
+// Defines scaffolding (found under .g8 folder)
+// http://www.foundweekends.org/giter8/scaffolding.html
+// sbt "g8Scaffold form"
+addSbtPlugin("org.foundweekends.giter8" % "sbt-giter8-scaffold" % "0.11.0")

play-framework/student-api/test/controllers/StudentControllerUnitTest.java

@@ -0,0 +1,95 @@
+package controllers;
+
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.junit.Test;
+import play.Application;
+import play.inject.guice.GuiceApplicationBuilder;
+import play.libs.Json;
+import play.mvc.Http;
+import play.mvc.Result;
+import play.test.WithApplication;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static play.mvc.Http.Status.OK;
+import static play.test.Helpers.*;
+
+public class StudentControllerUnitTest extends WithApplication {
+
+    @Override
+    protected Application provideApplication() {
+        return new GuiceApplicationBuilder().build();
+    }
+
+    @Test
+    public void givenStudentPostData_whenCreatingStudent_ThenShouldReturnCreatedStudent() {
+        final ObjectNode jsonNode = Json.newObject();
+        jsonNode.put("firstName", "John");
+        jsonNode.put("lastName", "Baeldung");
+        jsonNode.put("age", 25);
+
+        Http.RequestBuilder request = new Http.RequestBuilder()
+                .method(POST)
+                .bodyJson(jsonNode)
+                .uri("/");
+
+        Result result = route(app, request);
+        assertEquals(CREATED, result.status());
+        assertTrue(result.contentType().isPresent());
+        assertEquals("application/json", result.contentType().get());
+    }
+
+    @Test
+    public void givenUrlToListStudents_whenListingStudents_ThenShouldReturnStudentList() {
+        Http.RequestBuilder request = new Http.RequestBuilder()
+                .method(GET)
+                .uri("/");
+
+        Result result = route(app, request);
+        assertEquals(OK, result.status());
+        assertTrue(result.contentType().isPresent());
+        assertEquals("application/json", result.contentType().get());
+    }
+
+    @Test
+    public void givenUrlToRetrieveSingleStudent_whenRetrievingStudent_ThenShouldReturn404NotFound() {
+        Http.RequestBuilder request = new Http.RequestBuilder()
+                .method(GET)
+                .uri("/1");
+
+        Result result = route(app, request);
+        assertEquals(NOT_FOUND, result.status());
+        assertTrue(result.contentType().isPresent());
+        assertEquals("application/json", result.contentType().get());
+    }
+
+    @Test
+    public void givenUrlToUpdateStudent_whenaUpdatingStudent_ThenShouldFail() {
+        final ObjectNode jsonNode = Json.newObject();
+        jsonNode.put("firstName", "John");
+        jsonNode.put("lastName", "Baeldung");
+        jsonNode.put("age", 25);
+
+        Http.RequestBuilder request = new Http.RequestBuilder()
+                .method(PUT)
+                .bodyJson(jsonNode)
+                .uri("/");
+
+        Result result = route(app, request);
+        assertEquals(INTERNAL_SERVER_ERROR, result.status());
+        assertTrue(result.contentType().isPresent());
+        assertEquals("application/json", result.contentType().get());
+    }
+
+    @Test
+    public void givenIdToDeleteStudent_whenDeletingStudent_ThenShouldFail() {
+        Http.RequestBuilder request = new Http.RequestBuilder()
+                .method(DELETE)
+                .uri("/1");
+
+        Result result = route(app, request);
+        assertEquals(NOT_FOUND, result.status());
+        assertTrue(result.contentType().isPresent());
+        assertEquals("application/json", result.contentType().get());
+    }
+}