complete questionnaire

backend/src/main/java/api/JsonKeys.java

+package api;
+
+import com.github.cliftonlabs.json_simple.JsonKey;
+
+public enum JsonKeys implements JsonKey {
+    KEY_QUESTION("question"),
+    KEY_QUESTIONS("questions"),
+    KEY_ANSWER("answer"),
+    KEY_ANSWERS("answers"),
+    KEY_DESCRIPTION("description"),
+    KEY_NAME("name"),
+    KEY_ID("id");
+
+
+    private final Object value;
+
+    JsonKeys(Object iValue)
+    {
+        value = iValue;
+    }
+
+    @Override
+    public String getKey() {
+        return (String) value;
+    }
+
+    @Override
+    public Object getValue() {
+        return value;
+    }
+}

backend/src/main/java/api/ResponseHandler.java

 import com.sun.net.httpserver.HttpHandler;
 import controller.ModelController;
 import controller.QuestionnaireController;
+import controller.SessionController;
 
 import java.io.IOException;
 import java.io.OutputStream;
             // parse request body : either empty or a JSON Object
             // ---------------------------------
             if (iBody.length() > 0) {
-                Jsoner.deserialize(iBody, vRequestJson);
+                vRequestJson = Jsoner.deserialize(iBody, vRequestJson);
             }
 
             // ---------------------------------
                 case "GET":
                     switch (iPath.length) {
                         case 0:
-                            vResponseObject = iController.getAllEntries(vRequestJson); break;
+                            vResponseObject = iController.get(vRequestJson); break;
                         case 1:
                             vResponseObject = iController.getEntriesForId(iPath[0], vRequestJson); break;
                         default: throw new Exception(String.format("GET with %d subdirectories not implemented", iPath.length));
             }
         }catch(Exception vex)
         {
+            vex.printStackTrace();
             vResponseObject.put("error",vex.getMessage());
         }
 
         String[] vRequestURI = iExchange.getRequestURI().getPath().split("/");
         String vRequestMethod = iExchange.getRequestMethod();
         String vRequestBody = new String(iExchange.getRequestBody().readAllBytes());
+        iExchange.getResponseHeaders().set("Content-Type","application/json; charset=utf-8");
+        iExchange.getResponseHeaders().set("Access-Control-Allow-Origin", "*");
+        iExchange.getResponseHeaders().set("Access-Control-Allow-Methods", "*");
+        iExchange.getResponseHeaders().set("Access-Control-Allow-Headers", "*");
 
         try {
             if(vRequestURI.length < 1)
                 case "questionnaire":
                     vController = new QuestionnaireController();
                     break;
+                case "session":
+                    vController = new SessionController();
+                    break;
                 default:
                     throw new Exception(String.format("Unknown path '%s'", vRequestURI[1]));
             }
 
             vRequestAnswerBytes = getResponse(vRequestMethod, Arrays.copyOfRange(vRequestURI,2, vRequestURI.length), vRequestBody, vController).toJson().getBytes(StandardCharsets.UTF_8);
-            iExchange.getResponseHeaders().set("Content-Type","application/json; charset=utf-8");
-            iExchange.getResponseHeaders().set("Access-Control-Allow-Origin", "*");
             iExchange.sendResponseHeaders(200, vRequestAnswerBytes.length);
         }
         catch(Exception vex){
+            JsonObject vErrorJsonObect = new JsonObject();
+            vErrorJsonObect.put("error", vex.getMessage());
+            vRequestAnswerBytes = vErrorJsonObect.toJson().getBytes(StandardCharsets.UTF_8);
             vex.printStackTrace();
-            iExchange.sendResponseHeaders(405, vex.getMessage().getBytes(StandardCharsets.UTF_8).length);
-            vRequestAnswerBytes = vex.getMessage().getBytes(StandardCharsets.UTF_8);
+            iExchange.sendResponseHeaders(500, vRequestAnswerBytes.length);
             }
 
         vOutputStream.write(vRequestAnswerBytes);

backend/src/main/java/controller/ModelController.java

 
 public abstract class ModelController {
 
-    public JsonObject getAllEntries(JsonObject iBody) throws Exception{
+    public JsonObject get(JsonObject iBody) throws Exception{
         throw new Exception("Not implemented");
     }
 

backend/src/main/java/controller/QuestionnaireController.java

 
 public class QuestionnaireController extends ModelController {
 
-    public JsonObject getAllEntries(JsonObject iJsonObject)
+    public JsonObject get(JsonObject iJsonObject)
     {
         return Questionnaire.getTheOnlyExistingQuestionnaire().asJsonObject();
     }

backend/src/main/java/controller/SessionController.java

+package controller;
+
+import com.github.cliftonlabs.json_simple.JsonKey;
+import com.github.cliftonlabs.json_simple.JsonObject;
+import model.questionnaire.Answer;
+import model.questionnaire.Question;
+import model.questionnaire.Session;
+import java.util.UUID;
+
+import static api.JsonKeys.KEY_ANSWER;
+import static api.JsonKeys.KEY_QUESTION;
+
+public class SessionController extends ModelController {
+
+    public JsonObject get(JsonObject iJsonObject) {
+        return new Session().asJsonObject();
+    }
+
+    public JsonObject updateEntry(String iID, JsonObject iBody) throws Exception{
+        Session vSession = Session.getSessionForUUID(UUID.fromString(iID));
+        if(null == vSession)
+            throw new Exception(String.format("No session for UUID %s", iID));
+
+        String vQuestionId = iBody.getString(KEY_QUESTION);
+        String vAnswerId   = iBody.getString(KEY_ANSWER);
+        Question vQuestion = Question.getForUUID(UUID.fromString(vQuestionId));
+        if(null == vQuestion)
+            throw new Exception(String.format("No question for UUID %s",vQuestionId));
+        Answer vAnswer = vQuestion.getAnswerForUUID(UUID.fromString(vAnswerId));
+        if(null == vAnswer)
+            throw new Exception(String.format("No answer at index %d", vAnswerId));
+
+        vSession.getSessionAnswers().setAnswer(vQuestion, vAnswer);
+        System.out.println(vSession.asJsonObject().toString());
+        return new JsonObject();
+    }
+
+}

backend/src/main/java/model/questionnaire/Answer.java

 import java.nio.charset.StandardCharsets;
 import java.util.UUID;
 
+import static api.JsonKeys.KEY_DESCRIPTION;
+import static api.JsonKeys.KEY_ID;
+
 public class Answer implements Jsonable {
 
-    private UUID    fUUID;
+    private UUID fId;
     private float   fWeight;
     private Trait   fTrait;
     private String  fDescription;
 
     public Answer(String iDescription, Trait iTrait, float iWeight)
     {
-        fUUID           = UUID.randomUUID();    // I feel like I should check this is truly unique among answers
+        fId = UUID.randomUUID();    // I feel like I should check this is truly unique among answers
         fWeight         = iWeight;
         fTrait          = iTrait;
         fDescription    = iDescription;
 
     public Trait getTrait() { return fTrait; }
     public float getWeight() { return fWeight; }
-
+    public UUID getId() { return fId; }
 
     @Override
     public String toJson() {
     @Override
     public void toJson(Writer writable) throws IOException {
         final JsonObject vResult = new JsonObject();
-        vResult.put("description", fDescription);
-        vResult.put("id", fUUID.toString());
+        vResult.put(KEY_DESCRIPTION, fDescription);
+        vResult.put(KEY_ID, fId.toString());
         writable.write(new String(vResult.toJson().getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8));
     }
 }

backend/src/main/java/model/questionnaire/Question.java

 import java.io.StringWriter;
 import java.io.Writer;
 import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
 import java.util.List;
+import java.util.UUID;
+
+import static api.JsonKeys.*;
 
 public class Question implements Jsonable {
 
+    private static final HashMap<UUID, Question> sQuestions = new HashMap<>();
+    private UUID fId;
     private List<Answer> fAnswers;
     private String fName;
 
     public Question(String iName, List<Answer> iAnswers)
     {
+        fId = UUID.randomUUID();
         fName = iName;
         fAnswers = iAnswers;
+        sQuestions.put(fId, this);
+    }
+
+
+    public static Question getForUUID(UUID iId) {
+        return sQuestions.get(iId);
     }
 
+
+    public Answer getAnswerForUUID(UUID iId) {
+        return fAnswers.stream().filter( answer -> answer.getId().equals(iId)).findFirst().get();
+    }
+
+    // ------------------------------------------------------------------
+    // Jsonable Implementation
+    // ------------------------------------------------------------------
+
     @Override
     public String toJson() {
         final StringWriter writable = new StringWriter();
     @Override
     public void toJson(Writer writable) throws IOException {
         JsonObject vResult = new JsonObject();
-        vResult.put("name", fName);
-        vResult.put("answers", fAnswers);
+        vResult.put(KEY_NAME, fName);
+        vResult.put(KEY_ANSWERS, fAnswers);
+        vResult.put(KEY_ID, fId.toString());
         writable.write(new String(vResult.toJson().getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8));
     }
 }

backend/src/main/java/model/questionnaire/Questionnaire.java

 import java.util.ArrayList;
 import java.util.List;
 
+import static api.JsonKeys.KEY_NAME;
+import static api.JsonKeys.KEY_QUESTIONS;
+
 public class Questionnaire{
 
     private static List<Questionnaire> sQuestionnaires = new ArrayList<>();
 
     public JsonObject asJsonObject(){
         JsonObject vResult = new JsonObject();
-        vResult.put("name", fName);
-        vResult.put("questions",fQuestions);
+        vResult.put(KEY_NAME, fName);
+        vResult.put(KEY_QUESTIONS,fQuestions);
         return vResult;
     }
 }

backend/src/main/java/model/questionnaire/Session.java

 package model.questionnaire;
 
+import com.github.cliftonlabs.json_simple.JsonObject;
+import com.github.cliftonlabs.json_simple.Jsonable;
 import model.personnality.Personality;
 
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
 import java.util.UUID;
 
-public class Session {
+import static api.JsonKeys.KEY_ID;
 
+public class Session implements Jsonable {
+
+    private static HashMap<UUID, Session> sSessions = new HashMap<UUID, Session>();
     private UUID fId;
     private SessionAnswers fAnswers;
     private Personality    fPersonality;
 
-    public Session(UUID iId){
-        fId = iId;
+    public Session(){
+        fId = UUID.randomUUID();
         fAnswers = new SessionAnswers();
         fPersonality = new Personality();
+        sSessions.put(fId, this);
     }
 
+
     public SessionAnswers getSessionAnswers(){ return fAnswers; }
 
+    public static Session getSessionForUUID(UUID iId){
+        return sSessions.get(iId);
+    }
+
+
+    // ------------------------------------------------------------------
+    // Jsonable Implementation
+    // ------------------------------------------------------------------
+    public JsonObject asJsonObject() {
+        JsonObject vResult = new JsonObject();
+        vResult.put(KEY_ID, fId.toString());
+
+        return vResult;
+    }
+
+
+    @Override
+    public String toJson() {
+        final StringWriter writable = new StringWriter();
+        try{
+            this.toJson(writable);
+        }catch(final IOException caught)
+        {
+            caught.printStackTrace();
+        }
+        return writable.toString();
+    }
+
+
+    @Override
+    public void toJson(Writer writable) throws IOException {
+        writable.write(new String(asJsonObject().toJson().getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8));
+    }
 
 }

backend/src/main/java/model/questionnaire/SessionAnswers.java

     private HashMap<Trait, Float> fTraits;
 
     public SessionAnswers() {
+        fTraits = new HashMap<>();
         fAnswers = new HashMap<>();
     }
 

frontend/src/App.js

 import './App.css';
 import React from 'react';
 import Questionnaire from './component/questionnaire';
+import url from './server';
+
 
 function App() {
   const [questionnaireStarted, onStartQuestionnaire] = React.useState(false);
+  const [sessionIdReceived, onSessionIdReceived] = React.useState(null);
+  const [sessionIdRequested, onSessionIdRequested] = React.useState(false);
+  const [errorOccured, onErrorOccured] = React.useState(null);
+  //-------------------------------
+  // Fetch session id
+  //-------------------------------
+  if(null === sessionIdReceived && !sessionIdRequested)
+  {
+    onSessionIdRequested(true);
+    fetch(url+"/session")
+        .then(response => response.json())
+        .then(result => {
+            if('error' in result)
+              onErrorOccured(result.error);
+            else
+              onSessionIdReceived(result.id);
+        })
+        .catch( e => {
+            console.log(e);
+        });
+  }
 
   return (
     <div>
         Are you an introvert or an extrovert ?
       </h1>
       <div>
-        Take this ✨ totally legit test ✨ and find out !
+        Take this <i>✨ totally legit personality test ✨</i> and find out !
       </div>
       {
-        !questionnaireStarted && 
+        null === sessionIdReceived &&
+        <div> {null === errorOccured ? "Contacting server..." : "A server error occured 😨 : "+errorOccured} </div>
+      }
+      {
+        !questionnaireStarted && null!=sessionIdReceived &&
         <div
         onClick={() => onStartQuestionnaire(true)}>
           Start
         </div>
       }
       { questionnaireStarted &&
-        <Questionnaire/>}
+        <Questionnaire sessionId={sessionIdReceived}/>}
     </div>
   );
 }

frontend/src/component/question.js

 import React from 'react';
 import url from '../server';
+import Questionnaire from './questionnaire';
 
 function Question(props){
-    let question = props.questions[props.index];
-    const [selectedAnswer, onSelectAnswer] = React.useState(question.answer);
+    let current_question = props.questions[props.index];
+    const [selectedAnswer, onSelectAnswer] = React.useState(current_question.answer);
     let question_answers = [];
 
     //-------------------------------
     // Build question form
     //-------------------------------
-    question.answers.forEach(answer => {
+    current_question.answers.forEach(answer => {
         let dom_id = "answer"+answer.id
         question_answers.push(
             <div key={dom_id}>
     
     return (
     <div>
-        <div> {question.name} </div>
+        <div> {current_question.name} </div>
         <div onChange={(value) => onSelectAnswer(value.target.value)}>
         {question_answers}
         </div>
         <div
             onClick={() => {
+                //-------------------------------
+                // POST question answer
+                //-------------------------------
+                fetch(url+"/session/"+props.sessionId, {
+                    method:'PUT',
+                    body: JSON.stringify({
+                        question: current_question.id,
+                        answer: selectedAnswer
+                    }),
+                    headers: {"Content-type": "application/json; charset=UTF-8"}
+                }) 
+                .then(response => response.json())
+                .then(result => {
+                    if(props.index === props.questions.length - 1)
+                    {
+                        //-------------------------------
+                        // Tell the (parent) questionnaire that the results should be available
+                        //-------------------------------
+                        props.questionnaireCompleted(true);
+                    }
+                })
+                .catch( e => console.error(e))
+
                 if(props.index === props.questions.length - 1)
                 {
-                    question.answer = selectedAnswer;
+                    current_question.answer = selectedAnswer;
                 }
                 else
                 {
-                    question.answer = selectedAnswer;
+                    current_question.answer = selectedAnswer;
                     props.moveToQuestion(props.index + 1);
                 }
             }}>
-                {props.index < props.questions.length -1 ? "Validate" : "Get Result" }
+                {props.index < props.questions.length -1 ? "Validate" : "Get Results" }
         </div>
     </div>
     );

frontend/src/component/questionnaire.js

 import React from 'react';
 import url from '../server';
 import Question from './question';
+import QuestionnaireResult from './questionnaire_result';
 
-function Questionnaire(){
+function Questionnaire(props){
     const [currentIndex, onMoveToIndex] = React.useState(0);
     const [questionnaireDataFetched, onQuestionnaireDataFetched] = React.useState(null);
+    const [resultsAvailable, onQuestionnaireCompleted] = React.useState(false);
 
     //-------------------------------
     // Fetch questionnaire
         fetch(url+"/questionnaire")
             .then(response => response.json())
             .then(result => {
+                if('error' in result)
+                    console.error(result);
                 onQuestionnaireDataFetched(result);
             })
             .catch( e => {
                 console.log(e);
-            })
+            });
     }
 
+    if(!resultsAvailable)
     return (<React.Fragment>
         {
             null === questionnaireDataFetched ?
             :
             <Question
                 key={"question_"+currentIndex}   //force throw away to ease radio buttons management 
+                sessionId={props.sessionId}
                 questions={questionnaireDataFetched.questions}
                 index={currentIndex}
-                moveToQuestion={onMoveToIndex}/>
+                moveToQuestion={onMoveToIndex}
+                questionnaireCompleted={onQuestionnaireCompleted}/>
         }
         <div>
         {
         </div>
         </React.Fragment>
     )
+    else
+    return(
+        <QuestionnaireResult/>
+    )
 }
 
 export default Questionnaire;

frontend/src/component/questionnaire_result.js

+import React from 'react';
+import url from '../server';
+
+function QuestionnaireResult(props){
+    const [resultsFetched, onResultsFetched] = React.useState(null);
+
+    if(null === resultsFetched)
+    {
+        
+    }
+    return(
+        <div>
+            Results
+        </div>
+    )
+}
+
+export default QuestionnaireResult;