[TECH] Copier le ValidatorQroc dans le bounded context de devcomp (PIX-10025)

 #7536

Author: pix-service-auto-merge

api/src/devcomp/domain/models/Solution.js

@@ -0,0 +1,64 @@
+/**
+ * Traduction: Correction
+ * Context:    Objet existant dans le cadre de la correction d'une réponse pendant le fonctionnement
+ *             interne de l'algorithme.
+ */
+class Solution {
+  /**
+   *
+   * @param id: id de la ligne Épreuve du référentiel dont est extraite l'information de la Solution
+   * @param isT1Enabled: T1 - Espaces, casse & accents
+   * @param isT2Enabled: T2 - Ponctuation
+   * @param isT3Enabled: T3 - Distance d'édition
+   * @param type: type de l'épreuve
+   * @param value: Bonne réponse attendue.
+   *
+   * Les traitements T1, T2 et T3 sont les traitements qu'il est possible d'utiliser pour valider une réponse.
+   * Pour plus d'informations, ne pas hésiter à se reporter aux explications présentes dans pix-editor.
+   */
+  constructor({
+    id,
+    isT1Enabled = false,
+    isT2Enabled = false,
+    isT3Enabled = false,
+    type,
+    value,
+    qrocBlocksTypes,
+  } = {}) {
+    this.id = id;
+    this.isT1Enabled = isT1Enabled;
+    this.isT2Enabled = isT2Enabled;
+    this.isT3Enabled = isT3Enabled;
+    this.type = type;
+    this.value = value;
+    this.qrocBlocksTypes = qrocBlocksTypes;
+  }
+
+  get enabledTreatments() {
+    const enabledTreatments = [];
+    if (this.isT1Enabled) {
+      enabledTreatments.push('t1');
+    }
+    if (this.isT2Enabled) {
+      enabledTreatments.push('t2');
+    }
+    if (this.isT3Enabled) {
+      enabledTreatments.push('t3');
+    }
+    return enabledTreatments;
+  }
+
+  // TODO: delete when deactivation object is correctly deleted everywhere
+  /**
+   * @deprecated use the enabledTreatments property
+   */
+  get deactivations() {
+    return {
+      t1: !this.enabledTreatments.includes('t1'),
+      t2: !this.enabledTreatments.includes('t2'),
+      t3: !this.enabledTreatments.includes('t3'),
+    };
+  }
+}
+
+export { Solution };

api/src/devcomp/domain/models/validator/ValidatorQROC.js

@@ -0,0 +1,29 @@
+import * as solutionServiceQROC from '../../services/solution-service-qroc.js';
+import { Validation } from './Validation.js';
+import { Validator } from './Validator.js';
+
+/**
+ * Traduction: Vérificateur de réponse pour un QROC
+ */
+class ValidatorQROC extends Validator {
+  injectedSolutionServiceQROC;
+  constructor({ solutions } = {}, injectedSolutionServiceQROC = solutionServiceQROC) {
+    super({ solution: solutions });
+    this.injectedSolutionServiceQROC = injectedSolutionServiceQROC;
+  }
+
+  assess({ answer, challengeFormat }) {
+    const result = this.injectedSolutionServiceQROC.match({
+      answer: answer.value,
+      solutions: this.solution,
+      challengeFormat,
+    });
+
+    return new Validation({
+      result,
+      resultDetails: null,
+    });
+  }
+}
+
+export { ValidatorQROC };

api/src/devcomp/domain/services/services-utils.js

@@ -0,0 +1,13 @@
+import { _ } from '../../../shared/infrastructure/utils/lodash-utils.js';
+
+const ALL_TREATMENTS = ['t1', 't2', 't3'];
+
+function getEnabledTreatments(shouldApplyTreatments, deactivations) {
+  return shouldApplyTreatments ? ALL_TREATMENTS.filter((treatment) => !deactivations[treatment]) : [];
+}
+
+function useLevenshteinRatio(enabledTreatments) {
+  return _.includes(enabledTreatments, 't3');
+}
+
+export { getEnabledTreatments, useLevenshteinRatio };

api/src/devcomp/domain/services/solution-service-qroc.js

@@ -0,0 +1,56 @@
+import { cleanStringAndParseFloat, isNumeric } from '../../../shared/infrastructure/utils/string-utils.js';
+import lodash from 'lodash';
+import { applyPreTreatments, applyTreatments } from './validation-treatments.js';
+import { validateAnswer } from './string-comparison-service.js';
+import { AnswerStatus } from '../models/validator/AnswerStatus.js';
+import { getEnabledTreatments, useLevenshteinRatio } from './services-utils.js';
+
+const CHALLENGE_NUMBER_FORMAT = 'nombre';
+const { every, isEmpty, isString, map } = lodash;
+
+const match = function ({ answer, challengeFormat, solutions }) {
+  const deactivations = solutions.deactivations;
+  const qrocBlocksTypes = solutions.qrocBlocksTypes || {};
+  const shouldApplyTreatments = qrocBlocksTypes[Object.keys(qrocBlocksTypes)[0]] === 'select' ? false : true;
+
+  const isIncorrectAnswerFormat = !isString(answer);
+  const isIncorrectSolutionFormat = solutions.value?.some((s) => !isString(s) || isEmpty(s));
+
+  if (isIncorrectAnswerFormat || isIncorrectSolutionFormat) {
+    return AnswerStatus.KO;
+  }
+
+  const solutionsValue = solutions.value;
+  const areAllNumericSolutions = every(solutionsValue, (solution) => {
+    return isNumeric(solution);
+  });
+
+  if (isNumeric(answer) && areAllNumericSolutions && challengeFormat === CHALLENGE_NUMBER_FORMAT) {
+    return _getAnswerStatusFromNumberMatching(answer, solutionsValue);
+  }
+
+  return _getAnswerStatusFromStringMatching(answer, solutionsValue, deactivations, shouldApplyTreatments);
+};
+
+export { match };
+
+function _getAnswerStatusFromNumberMatching(answer, solutions) {
+  const treatedSolutions = solutions.map((solution) => cleanStringAndParseFloat(solution));
+  const treatedAnswer = cleanStringAndParseFloat(answer);
+  const indexOfSolution = treatedSolutions.indexOf(treatedAnswer);
+  const isAnswerMatchingSolution = indexOfSolution !== -1;
+  if (isAnswerMatchingSolution) {
+    return AnswerStatus.OK;
+  }
+  return AnswerStatus.KO;
+}
+
+function _getAnswerStatusFromStringMatching(answer, solutions, deactivations, shouldApplyTreatments) {
+  const enabledTreatments = getEnabledTreatments(shouldApplyTreatments, deactivations);
+  const treatedAnswer = applyTreatments(applyPreTreatments(answer), enabledTreatments);
+  const treatedSolutions = map(solutions, (solution) => applyTreatments(solution, enabledTreatments));
+
+  return validateAnswer(treatedAnswer, treatedSolutions, useLevenshteinRatio(enabledTreatments))
+    ? AnswerStatus.OK
+    : AnswerStatus.KO;
+}

api/src/devcomp/domain/services/string-comparison-service.js

@@ -0,0 +1,30 @@
+import _ from 'lodash';
+import levenshtein from 'fast-levenshtein';
+import { LEVENSHTEIN_DISTANCE_MAX_RATE } from '../../../shared/domain/constants.js';
+
+function isOneStringCloseEnoughFromMultipleStrings(inputString, references, MAX_ACCEPTABLE_RATIO) {
+  return getSmallestLevenshteinRatio(inputString, references) <= MAX_ACCEPTABLE_RATIO;
+}
+
+function getSmallestLevenshteinRatio(inputString, references) {
+  return getSmallestLevenshteinDistance(inputString, references) / inputString.length;
+}
+
+function getSmallestLevenshteinDistance(comparative, alternatives) {
+  const getLevenshteinDistance = (alternative) => levenshtein.get(comparative, alternative);
+  return _(alternatives).map(getLevenshteinDistance).min();
+}
+
+function validateAnswer(answer, solutions, useLevenshteinRatio) {
+  if (useLevenshteinRatio) {
+    return getSmallestLevenshteinRatio(answer, solutions) <= LEVENSHTEIN_DISTANCE_MAX_RATE;
+  }
+  return _.includes(solutions, answer);
+}
+
+export {
+  isOneStringCloseEnoughFromMultipleStrings,
+  getSmallestLevenshteinDistance,
+  getSmallestLevenshteinRatio,
+  validateAnswer,
+};

api/src/devcomp/domain/services/validation-treatments.js

@@ -0,0 +1,48 @@
+import _ from 'lodash';
+
+function normalizeAndRemoveAccents(value) {
+  // Remove uppercase/spaces/accents/diacritics, see http://stackoverflow.com/a/37511463/827989
+  return value
+    .toString()
+    .trim()
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/\s/g, '');
+}
+
+function removeSpecialCharacters(value) {
+  return value
+    .toString()
+    .replace(/[^a-zA-Z0-9 ]+/g, '')
+    .replace('/ {2,}/', ' ')
+    .replace(/\s\s+/g, ' ');
+}
+
+function applyPreTreatments(value) {
+  return value
+    .toString()
+    .normalize('NFC')
+    .replace(/\u00A0/g, ' ');
+}
+
+const treatments = {
+  t1: normalizeAndRemoveAccents,
+  t2: removeSpecialCharacters,
+};
+
+function applyTreatments(string, enabledTreatments) {
+  let result = string.toString();
+  if (_.isEmpty(enabledTreatments)) {
+    return result;
+  }
+  _(enabledTreatments)
+    .sort()
+    .each((treatment) => {
+      const treatmentFunction = _.get(treatments, treatment);
+      result = treatmentFunction ? treatmentFunction(result) : result;
+    });
+  return result;
+}
+
+export { normalizeAndRemoveAccents, removeSpecialCharacters, applyPreTreatments, applyTreatments, treatments };

api/tests/devcomp/tooling/domain-builder/factory/build-solution.js

@@ -0,0 +1,21 @@
+import { Solution } from '../../../../../src/devcomp/domain/models/Solution.js';
+
+const buildSolution = function ({
+  id = 'recCHAL123',
+  type = 'QCM',
+  value = ['1'],
+  isT1Enabled = false,
+  isT2Enabled = false,
+  isT3Enabled = false,
+} = {}) {
+  return new Solution({
+    id,
+    type,
+    value,
+    isT1Enabled,
+    isT2Enabled,
+    isT3Enabled,
+  });
+};
+
+export { buildSolution };

api/tests/devcomp/tooling/domain-builder/factory/index.js

@@ -0,0 +1,3 @@
+import { buildSolution } from './build-solution.js';
+
+export { buildSolution };