get questionnaire

backend/.idea/encodings.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Encoding">
+    <file url="PROJECT" charset="UTF-8" />
+  </component>
+</project>

backend/build.gradle

 }
 
 dependencies {
+    compile 'com.github.cliftonlabs:json-simple:3.1.1'
+}
+
+dependencies {
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
 }

backend/src/main/java/Application.java

+import api.ResponseHandler;
+import com.sun.net.httpserver.HttpServer;
+import model.personnality.Trait;
+import model.questionnaire.Answer;
+import model.questionnaire.Question;
+import model.questionnaire.Questionnaire;
+
+import java.net.InetSocketAddress;
+import java.util.Arrays;
+
 public class Application {
+
+    public static void main(String [] args)
+    {
+        Trait vExtrovertTrait = new Trait("Extrovert", "You're an extrovert");
+        Trait vIntrovertTrait = new Trait("Introvert", "You're an introvert");
+
+        //------------------------------------
+        // Define questionnaire
+        //------------------------------------
+        Questionnaire vQuestionnaire = new Questionnaire(
+                "Introvert or extrovert ?",
+                Arrays.asList(
+                        //------------------------------------
+                        // First question
+                        //------------------------------------
+                        new Question(
+                                "You're really busy at work and a colleague is telling you their life story and personal woes.",
+                                Arrays.asList(
+                                        new Answer("Don't dare to interrupt them", vIntrovertTrait, 0.5f),
+                                        new Answer("Think it's more important to give them some of your time; work can wait", vIntrovertTrait, 0.2f),
+                                        new Answer("Listen, but with only with half an ear ", vIntrovertTrait, 0.1f),
+                                        new Answer("Interrupt and explain that you are really busy at the moment", vExtrovertTrait, 0.5f)
+                                )
+                        ),
+                        //------------------------------------
+                        // Second question
+                        //------------------------------------
+                        new Question(
+                                "You've been sitting in the doctor's waiting room for more than 25 minutes.",
+                                Arrays.asList(
+                                        new Answer("Look at your watch every two minutes", vIntrovertTrait, 0.2f),
+                                        new Answer("Bubble with inner anger, but keep quiet ", vIntrovertTrait, 0.5f),
+                                        new Answer("Explain to other equally impatient people in the room that the doctor is always running late ", vExtrovertTrait, 0.3f),
+                                        new Answer("Complain in a loud voice, while tapping your foot impatiently", vExtrovertTrait, 0.7f)
+                                )
+                        )
+                )
+        );
+
+        //------------------------------------
+        // Start server
+        //------------------------------------
+        try {
+            HttpServer vServer = HttpServer.create(new InetSocketAddress(8080), 0);
+            vServer.createContext("/", new ResponseHandler());
+            vServer.setExecutor(null);
+            vServer.start();
+        }
+        catch(Exception ve)
+        {
+            ve.printStackTrace();
+        }
+    }
+
 }

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

+package api;
+
+import com.github.cliftonlabs.json_simple.JsonObject;
+import com.github.cliftonlabs.json_simple.Jsoner;
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpHandler;
+import controller.ModelController;
+import controller.QuestionnaireController;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+
+public class ResponseHandler implements HttpHandler {
+
+    public JsonObject getResponse(String iMethod, String [] iPath, String iBody, ModelController iController)
+    {
+        JsonObject vResponseObject = new JsonObject();
+        JsonObject vRequestJson = new JsonObject();
+
+        try {
+            // ---------------------------------
+            // parse request body : either empty or a JSON Object
+            // ---------------------------------
+            if (iBody.length() > 0) {
+                Jsoner.deserialize(iBody, vRequestJson);
+            }
+
+            // ---------------------------------
+            // Decide which controller method should process the request
+            // ---------------------------------
+            switch (iMethod) {
+                case "GET":
+                    switch (iPath.length) {
+                        case 0:
+                            vResponseObject = iController.getAllEntries(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));
+                    }
+                    break;
+                case "POST":
+                    switch (iPath.length) {
+                        case 1: vResponseObject = iController.createEntry(vRequestJson); break;
+                        default: throw new Exception(String.format("POST with %d subdirectories not implemented", iPath.length));
+                    }
+                    break;
+                case "PUT":
+                    switch (iPath.length) {
+                        case 1: vResponseObject = iController.updateEntry(iPath[0], vRequestJson); break;
+                        default: throw new Exception(String.format("PUT with %d subdirectories not implemented", iPath.length));
+                    }
+                    break;
+                case "DELETE":
+                    switch (iPath.length) {
+                        case 1: vResponseObject = iController.deleteEntry(iPath[0]); break;
+                        default: throw new Exception(String.format("DELETE with %d subdirectories not implemented", iPath.length));
+                    }break;
+                default: throw new Exception(String.format("Method '%s' not implemented", iMethod));
+            }
+        }catch(Exception vex)
+        {
+            vResponseObject.put("error",vex.getMessage());
+        }
+
+        return vResponseObject;
+    }
+
+    @Override
+    public void handle(HttpExchange iExchange) throws IOException {
+        ModelController vController;
+        byte[] vRequestAnswerBytes;
+        OutputStream vOutputStream = iExchange.getResponseBody();
+        String[] vRequestURI = iExchange.getRequestURI().getPath().split("/");
+        String vRequestMethod = iExchange.getRequestMethod();
+        String vRequestBody = new String(iExchange.getRequestBody().readAllBytes());
+
+        try {
+            if(vRequestURI.length < 1)
+                throw new Exception(String.format("Unusable path '%s'", iExchange.getRequestURI().getPath()));
+
+            switch (vRequestURI[1]) {
+                case "questionnaire":
+                    vController = new QuestionnaireController();
+                    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){
+            vex.printStackTrace();
+            iExchange.sendResponseHeaders(405, vex.getMessage().getBytes(StandardCharsets.UTF_8).length);
+            vRequestAnswerBytes = vex.getMessage().getBytes(StandardCharsets.UTF_8);
+            }
+
+        vOutputStream.write(vRequestAnswerBytes);
+        vOutputStream.close();
+    }
+}

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

+package controller;
+
+import com.github.cliftonlabs.json_simple.JsonObject;
+
+public abstract class ModelController {
+
+    public JsonObject getAllEntries(JsonObject iBody) throws Exception{
+        throw new Exception("Not implemented");
+    }
+
+    public JsonObject getEntriesForId(String iId, JsonObject iBody) throws Exception{
+        throw new Exception("Not implemented");
+    }
+
+    public JsonObject createEntry(JsonObject iBody) throws Exception{
+        throw new Exception("Not implemented");
+    }
+
+    public JsonObject updateEntry(String iID, JsonObject iBody) throws Exception{
+        throw new Exception("Not implemented");
+    }
+
+    public JsonObject deleteEntry(String iId) throws Exception{
+        throw new Exception("Not implemented");
+    }
+
+}

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

+package controller;
+
+import com.github.cliftonlabs.json_simple.JsonObject;
+import model.questionnaire.Questionnaire;
+
+public class QuestionnaireController extends ModelController {
+
+    public JsonObject getAllEntries(JsonObject iJsonObject)
+    {
+        return Questionnaire.getTheOnlyExistingQuestionnaire().asJsonObject();
+    }
+}

backend/src/main/java/model/personnality/Personality.java

+package model.personnality;
+
+import java.util.HashMap;
+
+public class Personality {
+
+    private HashMap<Trait, Float> fTraits;
+
+    public Personality()
+    {
+        fTraits = new HashMap<>();
+    }
+}

backend/src/main/java/model/personnality/Trait.java

+package model.personnality;
+
+public class Trait {
+
+    private String fName;
+    private String fDescription;
+
+    public Trait(String iName, String iDescription){
+        fName           = iName;
+        fDescription    = iDescription;
+    }
+}

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

+package model.questionnaire;
+
+import com.github.cliftonlabs.json_simple.JsonObject;
+import com.github.cliftonlabs.json_simple.Jsonable;
+import model.personnality.Trait;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.util.UUID;
+
+public class Answer implements Jsonable {
+
+    private UUID    fUUID;
+    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
+        fWeight         = iWeight;
+        fTrait          = iTrait;
+        fDescription    = iDescription;
+    }
+
+    public Trait getTrait() { return fTrait; }
+    public float getWeight() { return fWeight; }
+
+
+    @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 {
+        final JsonObject vResult = new JsonObject();
+        vResult.put("description", fDescription);
+        vResult.put("id", fUUID.toString());
+        writable.write(new String(vResult.toJson().getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8));
+    }
+}

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

+package model.questionnaire;
+
+import com.github.cliftonlabs.json_simple.JsonObject;
+import com.github.cliftonlabs.json_simple.Jsonable;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+public class Question implements Jsonable {
+
+    private List<Answer> fAnswers;
+    private String fName;
+
+    public Question(String iName, List<Answer> iAnswers)
+    {
+        fName = iName;
+        fAnswers = iAnswers;
+    }
+
+    @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 {
+        JsonObject vResult = new JsonObject();
+        vResult.put("name", fName);
+        vResult.put("answers", fAnswers);
+        writable.write(new String(vResult.toJson().getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8));
+    }
+}

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

+package model.questionnaire;
+
+import com.github.cliftonlabs.json_simple.JsonObject;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Questionnaire{
+
+    private static List<Questionnaire> sQuestionnaires = new ArrayList<>();
+    private List<Question> fQuestions;
+    private String fName;
+
+    public Questionnaire(String iName, List<Question> iQuestions)
+    {
+        fName = iName;
+        fQuestions = iQuestions;
+        sQuestionnaires.add(this);
+    }
+
+    public static Questionnaire getTheOnlyExistingQuestionnaire(){
+        return sQuestionnaires.stream().findFirst().get();
+    }
+
+    public JsonObject asJsonObject(){
+        JsonObject vResult = new JsonObject();
+        vResult.put("name", fName);
+        vResult.put("questions",fQuestions);
+        return vResult;
+    }
+}

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

+package model.questionnaire;
+
+import model.personnality.Personality;
+
+import java.util.UUID;
+
+public class Session {
+
+    private UUID fId;
+    private SessionAnswers fAnswers;
+    private Personality    fPersonality;
+
+    public Session(UUID iId){
+        fId = iId;
+        fAnswers = new SessionAnswers();
+        fPersonality = new Personality();
+    }
+
+    public SessionAnswers getSessionAnswers(){ return fAnswers; }
+
+
+}

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

+package model.questionnaire;
+
+import model.personnality.Personality;
+import model.personnality.Trait;
+
+import java.util.HashMap;
+
+/**
+ * Stores answers provided for a session of answers
+ */
+public class SessionAnswers {
+
+    private HashMap<Question, Answer> fAnswers;
+    private HashMap<Trait, Float> fTraits;
+
+    public SessionAnswers() {
+        fAnswers = new HashMap<>();
+    }
+
+    /**
+     * Stores an answer to a question and updates the weight of the related trait.
+     * If an answer has already been provided for the question, cancel the weight added by the outdated answer
+     * @param iQuestion
+     * @param iAnswer
+     */
+    public void setAnswer(Question iQuestion, Answer iAnswer) {
+        // ---------------------------------
+        // cancel the weight added by a potential previous answer
+        // ---------------------------------
+        if(fAnswers.containsKey(iQuestion)) {
+            Answer vPreviousAnswer = fAnswers.get(iQuestion);
+            Trait vPreviousTrait = vPreviousAnswer.getTrait();
+            Float vOutdatedWeight = fTraits.get(vPreviousTrait);
+            fTraits.put(vPreviousTrait, vOutdatedWeight - vPreviousAnswer.getWeight());
+        }
+        // ---------------------------------
+        // Store the answer & update the related trait
+        // ---------------------------------
+        Trait vNewTrait = iAnswer.getTrait();
+        Float vNewTraitWeight = iAnswer.getWeight();
+        fAnswers.put(iQuestion, iAnswer);
+
+        if(fTraits.containsKey(vNewTrait))
+            vNewTraitWeight += fTraits.get(vNewTrait);
+
+        fTraits.put(vNewTrait, vNewTraitWeight);
+    }
+
+}

backend/src/test/java/api/ResponseHandlerTest.java

+package api;
+
+import com.github.cliftonlabs.json_simple.JsonObject;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+
+class ResponseHandlerTest {
+
+    @Test
+    public void TestGetResponse(){
+        ResponseHandler vResponseHandler = new ResponseHandler();
+
+        String [] vPath = {};
+        JsonObject vErrorObject = new JsonObject();
+
+        vErrorObject.put("error", "Method 'CAFE' not implemented");
+        assertEquals(vErrorObject, vResponseHandler.getResponse("CAFE", vPath, "Yo", null));
+
+        vErrorObject.put("error", "DELETE with 0 subdirectories not implemented");
+        assertEquals(vErrorObject, vResponseHandler.getResponse("DELETE", vPath, "Yo", null));
+
+        vPath = new String[]{"elo", "elo"};
+        vErrorObject.put("error", "DELETE with 2 subdirectories not implemented");
+        assertEquals(vErrorObject, vResponseHandler.getResponse("DELETE", vPath, "Yo", null));
+
+    }
+}

frontend/src/App.css

-.App {
-  text-align: center;
-}
-
-.App-logo {
-  height: 40vmin;
-  pointer-events: none;
-}
-
-@media (prefers-reduced-motion: no-preference) {
-  .App-logo {
-    animation: App-logo-spin infinite 20s linear;
-  }
-}
-
-.App-header {
-  background-color: #282c34;
-  min-height: 100vh;
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  font-size: calc(10px + 2vmin);
-  color: white;
-}
-
-.App-link {
-  color: #61dafb;
-}
-
-@keyframes App-logo-spin {
-  from {
-    transform: rotate(0deg);
-  }
-  to {
-    transform: rotate(360deg);
-  }
-}

frontend/src/App.js

-import logo from './logo.svg';
 import './App.css';
+import React from 'react';
+import Questionnaire from './component/questionnaire';
 
 function App() {
+  const [questionnaireStarted, onStartQuestionnaire] = React.useState(false);
+
   return (
-    <div className="App">
-      <header className="App-header">
-        <img src={logo} className="App-logo" alt="logo" />
-        <p>
-          Edit <code>src/App.js</code> and save to reload.
-        </p>
-        <a
-          className="App-link"
-          href="https://reactjs.org"
-          target="_blank"
-          rel="noopener noreferrer"
-        >
-          Learn React
-        </a>
-      </header>
+    <div>
+      <h1>
+        Are you an introvert or an extrovert ?
+      </h1>
+      <div>
+        Take this ✨ totally legit test ✨ and find out !
+      </div>
+      {
+        !questionnaireStarted && 
+        <div
+        onClick={() => onStartQuestionnaire(true)}>
+          Start
+        </div>
+      }
+      { questionnaireStarted &&
+        <Questionnaire/>}
     </div>
   );
 }

frontend/src/component/question.js

+import React from 'react';
+import url from '../server';
+
+function Question(props){
+    let question = props.questions[props.index];
+    const [selectedAnswer, onSelectAnswer] = React.useState(question.answer);
+    let question_answers = [];
+
+    //-------------------------------
+    // Build question form
+    //-------------------------------
+    question.answers.forEach(answer => {
+        let dom_id = "answer"+answer.id
+        question_answers.push(
+            <div key={dom_id}>
+                <input name="answer" id={dom_id} type="radio" value={answer.id} defaultChecked={answer.id === selectedAnswer}/>
+                <label htmlFor={dom_id}>{answer.description}</label>
+            </div>
+        );
+    });
+    
+    return (
+    <div>
+        <div> {question.name} </div>
+        <div onChange={(value) => onSelectAnswer(value.target.value)}>
+        {question_answers}
+        </div>
+        <div
+            onClick={() => {
+                if(props.index === props.questions.length - 1)
+                {
+                    question.answer = selectedAnswer;
+                }
+                else
+                {
+                    question.answer = selectedAnswer;
+                    props.moveToQuestion(props.index + 1);
+                }
+            }}>
+                {props.index < props.questions.length -1 ? "Validate" : "Get Result" }
+        </div>
+    </div>
+    );
+}
+
+export default Question;

frontend/src/component/questionnaire.js

+import React from 'react';
+import url from '../server';
+import Question from './question';
+
+function Questionnaire(){
+    const [currentIndex, onMoveToIndex] = React.useState(0);
+    const [questionnaireDataFetched, onQuestionnaireDataFetched] = React.useState(null);
+
+    //-------------------------------
+    // Fetch questionnaire
+    //-------------------------------
+    if(null === questionnaireDataFetched)
+    {
+        fetch(url+"/questionnaire")
+            .then(response => response.json())
+            .then(result => {
+                onQuestionnaireDataFetched(result);
+            })
+            .catch( e => {
+                console.log(e);
+            })
+    }
+
+    return (<React.Fragment>
+        {
+            null === questionnaireDataFetched ?
+            <div> Questionnaire is loading </div>
+            :
+            <Question
+                key={"question_"+currentIndex}   //force throw away to ease radio buttons management 
+                questions={questionnaireDataFetched.questions}
+                index={currentIndex}
+                moveToQuestion={onMoveToIndex}/>
+        }
+        <div>
+        {
+            currentIndex > 0 ? <div onClick={() => onMoveToIndex(currentIndex-1)}>Previous Question</div> : ''  
+        }
+        {
+            null != questionnaireDataFetched && currentIndex < questionnaireDataFetched.questions.length - 1 && 'answer' in questionnaireDataFetched.questions[currentIndex] && 
+            <div onClick={() => onMoveToIndex(currentIndex+1)}>Next Question</div>
+        }
+        </div>
+        </React.Fragment>
+    )
+}
+
+export default Questionnaire;

frontend/src/server.js

+let url = "";
+switch(process.env.NODE_ENV) {
+  case 'production':
+    url = 'https://demisel.space/garage/';
+    break;
+  case 'development':
+  default:
+    url = 'http://192.168.0.12:8080';
+}
+
+export default url