[#342] [FEATURE] Affichage de la zone de correction pour les challenges QROCM-ind (US-385)

api/db/migrations/20170329153349_update_answers--add_column_result_details.js

@@ -0,0 +1,17 @@
+const TABLE_NAME = 'answers';
+
+exports.up = function(knex, Promise) {
+  return Promise.all([
+    knex.schema.table(TABLE_NAME, function(table){
+      table.text('resultDetails');
+    })
+  ]);
+};
+
+exports.down = function(knex, Promise) {
+  return Promise.all([
+    knex.schema.table(TABLE_NAME, function(table){
+      table.dropColumn('resultDetails');
+    })
+  ]);
+};

api/lib/application/answers/answer-controller.js

@@ -4,21 +4,25 @@ const answerSerializer = require('../../infrastructure/serializers/jsonapi/answe
 const solutionRepository = require('../../infrastructure/repositories/solution-repository');
 const answerRepository = require('../../infrastructure/repositories/answer-repository');
 const solutionService = require('../../domain/services/solution-service');
+const jsYaml = require('js-yaml');
 
 function _updateExistingAnswer(existingAnswer, newAnswer, reply) {
   solutionRepository
     .get(existingAnswer.get('challengeId'))
     .then((solution) => {
-      const answerCorrectness = solutionService.match(newAnswer, solution);
+      const answerCorrectness = solutionService.validate(newAnswer, solution);
       new Answer({ id: existingAnswer.id })
         .save({
-          result: answerCorrectness,
+          result: answerCorrectness.result,
+          resultDetails: jsYaml.safeDump(answerCorrectness.resultDetails),
           value: newAnswer.get('value'),
           timeout: newAnswer.get('timeout'),
           challengeId: existingAnswer.get('challengeId'),
           assessmentId: existingAnswer.get('assessmentId')
         }, { method: 'update' })
-        .then((updatedAnswer) => reply(answerSerializer.serialize(updatedAnswer)).code(200))
+        .then((updatedAnswer) => {
+          return reply(answerSerializer.serialize(updatedAnswer)).code(200);
+        })
         .catch((err) => reply(Boom.badImplementation(err)));
     });
 }
@@ -27,8 +31,9 @@ function _saveNewAnswer(newAnswer, reply) {
   solutionRepository
     .get(newAnswer.get('challengeId'))
     .then((solution) => {
-      const answerCorrectness = solutionService.match(newAnswer, solution);
-      newAnswer.set('result', answerCorrectness);
+      const answerValidation = solutionService.validate(newAnswer, solution);
+      newAnswer.set('result', answerValidation.result);
+      newAnswer.set('resultDetails', jsYaml.safeDump(answerValidation.resultDetails));
       newAnswer.set('timeout', newAnswer.get('timeout'));
       newAnswer.set('elapsedTime', newAnswer.get('elapsedTime'));
       newAnswer.save()

api/lib/domain/services/solution-service-qcm.js

@@ -1,6 +1,5 @@
 const _ = require('../../infrastructure/utils/lodash-utils');
 
-
 module.exports = {
 
   match (answer, solution) {

api/lib/domain/services/solution-service-qroc.js

@@ -1,53 +1,47 @@
 const utils = require('./solution-service-utils');
 const deactivationsService = require('./deactivations-service');
 const _ = require('../../infrastructure/utils/lodash-utils');
+const { t1, t2, applyPreTreatments } = require('./validation-treatments');
 
 function _applyPreTreatmentsToSolutions(solution) {
-  return  _.chain(solution)
-            .split('\n')
-            .reject(_.isEmpty)
-            .value();
+  return _.chain(solution)
+    .split('\n')
+    .reject(_.isEmpty)
+    .value();
 }
 
 function _applyTreatmentsToSolutions(solution, deactivations) {
   const pretreatedSolutions = _applyPreTreatmentsToSolutions(solution);
-  return  _.map(pretreatedSolutions, (pretreatedSolution) => {
+  return _.map(pretreatedSolutions, (pretreatedSolution) => {
 
     if (deactivationsService.isDefault(deactivations)) {
-      return utils._treatmentT2(utils._treatmentT1(pretreatedSolution));
+      return t2(t1(pretreatedSolution));
     }
     else if (deactivationsService.hasOnlyT1(deactivations)) {
-      return utils._treatmentT2(pretreatedSolution);
+      return t2(pretreatedSolution);
     }
     else if (deactivationsService.hasOnlyT2(deactivations)) {
-      return utils._treatmentT1(pretreatedSolution);
+      return t1(pretreatedSolution);
     }
     else if (deactivationsService.hasOnlyT3(deactivations)) {
-      return utils._treatmentT2(utils._treatmentT1(pretreatedSolution));
+      return t2(t1(pretreatedSolution));
     }
     else if (deactivationsService.hasOnlyT1T2(deactivations)) {
       return pretreatedSolution;
     }
     else if (deactivationsService.hasOnlyT1T3(deactivations)) {
-      return utils._treatmentT2(pretreatedSolution);
+      return t2(pretreatedSolution);
     }
     else if (deactivationsService.hasOnlyT2T3(deactivations)) {
-      return utils._treatmentT1(pretreatedSolution);
+      return t1(pretreatedSolution);
     }
     else if (deactivationsService.hasT1T2T3(deactivations)) {
       return pretreatedSolution;
     }
-
   });
 }
 
-// remove unbreakable space
-function _applyAnswerTreatment(strArg) {
-  return strArg.replace(/\u00A0/g, ' ');
-}
-
-
-function _calculateResult(validations, deactivations) {
+function _formatResult(validations, deactivations) {
 
   if (deactivationsService.isDefault(deactivations)) {
     if (validations.t1t2t3Ratio <= 0.25) {
@@ -97,24 +91,24 @@ function _calculateResult(validations, deactivations) {
     }
     return 'ko';
   }
-
 }
 
-
 module.exports = {
 
   match (answer, solution, deactivations) {
 
-    if (_.isNotString(answer) || _.isNotString(solution) || _.isEmpty(solution)) {
+    // Input checking
+    if (!_.isString(answer)
+      || !_.isString(solution)
+      || _.isEmpty(solution)) {
       return 'ko';
     }
 
-    const treatedAnswer = _applyAnswerTreatment(answer);
+    const treatedAnswer = applyPreTreatments(answer);
     const treatedSolutions = _applyTreatmentsToSolutions(solution, deactivations);
 
     const validations = utils.treatmentT1T2T3(treatedAnswer, treatedSolutions);
 
-    return _calculateResult(validations, deactivations);
-
+    return _formatResult(validations, deactivations);
   }
 };

api/lib/domain/services/solution-service-qrocm-dep.js

@@ -1,32 +1,31 @@
-/*eslint no-console: ["error", { allow: ["warn", "error"] }] */
 const jsYaml = require('js-yaml');
 const _ = require('../../infrastructure/utils/lodash-utils');
 const utils = require('./solution-service-utils');
 const deactivationsService = require('./deactivations-service');
-
+const { t1, t2, applyPreTreatments } = require('./validation-treatments');
 
 function _applyTreatmentsToSolutions(solutions, deactivations) {
   return _.mapValues(solutions, (validSolutions) => {
     return _.map(validSolutions, (validSolution) => {
       const pretreatedSolution = validSolution.toString();
 
       if (deactivationsService.isDefault(deactivations)) {
-        return utils._treatmentT2(utils._treatmentT1(pretreatedSolution));
+        return t2(t1(pretreatedSolution));
       }
       else if (deactivationsService.hasOnlyT1(deactivations)) {
-        return utils._treatmentT2(pretreatedSolution);
+        return t2(pretreatedSolution);
       }
       else if (deactivationsService.hasOnlyT2(deactivations)) {
-        return utils._treatmentT1(pretreatedSolution);
+        return t1(pretreatedSolution);
       }
       else if (deactivationsService.hasOnlyT3(deactivations)) {
-        return utils._treatmentT2(utils._treatmentT1(pretreatedSolution));
+        return t2(t1(pretreatedSolution));
       }
       else if (deactivationsService.hasOnlyT1T2(deactivations)) {
         return pretreatedSolution;
       }
       else if (deactivationsService.hasOnlyT1T3(deactivations)) {
-        return utils._treatmentT2(pretreatedSolution);
+        return t2(pretreatedSolution);
       }
       else if (deactivationsService.hasT1T2T3(deactivations)) {
         return pretreatedSolution;
@@ -35,13 +34,11 @@ function _applyTreatmentsToSolutions(solutions, deactivations) {
   });
 }
 
-
 function _applyTreatmentsToAnswers(answers) {
   return _.mapValues(answers, _.toString);
 }
 
-
-function _calculateValidation(answers, solutions) {
+function _compareAnswersAndSolutions(answers, solutions) {
 
   const validations = {};
 
@@ -104,7 +101,7 @@ function _goodAnswer(allValidations, deactivations) {
   }
 }
 
-function _calculateResult(scoring, validations, deactivations) {
+function _formatResult(scoring, validations, deactivations) {
   let result = 'ok';
 
   const numberOfGoodAnswers = _numberOfGoodAnswers(validations, deactivations);
@@ -129,39 +126,33 @@ function _calculateResult(scoring, validations, deactivations) {
   return result;
 }
 
-function _applyPreTreatmentsToAnswer(yamlAnswer) {
-  return yamlAnswer.replace(/\u00A0/g, ' ');
-}
-
 module.exports = {
+
   match(yamlAnswer, yamlSolution, yamlScoring, deactivations) {
 
-    // Validate inputs
-    if (_.isNotString(yamlAnswer)
-        || _.isNotString(yamlSolution)
+    // Input checking
+    if (!_.isString(yamlAnswer)
         || _.isEmpty(yamlAnswer)
         || !_.includes(yamlSolution, '\n')) {
       return 'ko';
     }
 
     // Pre-Treatments
-    const preTreatedAnswers = _applyPreTreatmentsToAnswer(yamlAnswer);
+    const preTreatedAnswers = applyPreTreatments(yamlAnswer);
 
-    // remove unbreakable spaces
     // Convert Yaml to JS objects
     const answers = jsYaml.safeLoad(preTreatedAnswers);
     const solutions = jsYaml.safeLoad(yamlSolution);
     const scoring = jsYaml.safeLoad(_.ensureString(yamlScoring));
 
-
     // Treatments
     const treatedSolutions = _applyTreatmentsToSolutions(solutions, deactivations);
     const treatedAnswers = _applyTreatmentsToAnswers(answers);
 
     // Comparisons
-    const fullValidations = _calculateValidation(treatedAnswers, treatedSolutions);
+    const fullValidations = _compareAnswersAndSolutions(treatedAnswers, treatedSolutions);
 
-    return _calculateResult(scoring, fullValidations, deactivations);
+    return _formatResult(scoring, fullValidations, deactivations);
   }
 
 };