@pie-element/ebsr 14.2.1 → 14.2.2-next.0

package/controller/src/index.js

@@ -1,442 +0,0 @@
-import defaults from './defaults';
-import { lockChoices, getShuffledChoices, partialScoring } from '@pie-lib/controller-utils';
-import { isResponseCorrect } from './utils';
-import { get, isEmpty } from 'lodash-es';
-import Translator from '@pie-lib/translator';
-
-const { translator } = Translator;
-
-const prepareChoice = (model, env, defaultFeedback) => (choice) => {
-  const out = {
-    label: choice.label,
-    value: choice.value,
-  };
-
-  if (env.role === 'instructor' && (env.mode === 'view' || env.mode === 'evaluate')) {
-    out.rationale = model.rationaleEnabled ? choice.rationale : null;
-  } else {
-    out.rationale = null;
-  }
-
-  if (env.mode === 'evaluate') {
-    out.correct = !!choice.correct;
-
-    if (model.feedbackEnabled) {
-      const feedbackType = (choice.feedback && choice.feedback.type) || 'none';
-
-      if (feedbackType === 'default') {
-        out.feedback = defaultFeedback[choice.correct ? 'correct' : 'incorrect'];
-      } else if (feedbackType === 'custom') {
-        out.feedback = choice.feedback.value;
-      }
-    }
-  }
-
-  return out;
-};
-
-const parsePart = (part, key, session, env) => {
-  const defaultFeedback = Object.assign({ correct: 'Correct', incorrect: 'Incorrect' }, part.defaultFeedback);
-
-  let choices = part.choices ? part.choices.map(prepareChoice(part, env, defaultFeedback)) : [];
-
-  return {
-    ...part,
-    choices,
-    disabled: env.mode !== 'gather',
-    complete: {
-      min: part.choices.filter((c) => c.correct).length,
-    },
-    responseCorrect: env.mode === 'evaluate' ? isResponseCorrect(part, key, session) : undefined,
-  };
-};
-
-const normalizePart = (model, base) => ({
-  ...base,
-  ...model,
-  choicesLayout: model.choicesLayout || (model.verticalMode === false && 'horizontal') || 'vertical',
-});
-
-export const normalize = ({ partA = {}, partB = {}, language, ...question }) => ({
-  ...defaults,
-  ...question,
-  partA: normalizePart(partA, { ...defaults.partA, language }),
-  partB: normalizePart(partB, { ...defaults.partB, language }),
-});
-
-/**
- *
- * @param {*} question
- * @param {*} session
- * @param {*} env
- * @param {*} updateSession - optional - a function that will set the properties passed into it on the session.
- */
-export async function model(question, session, env, updateSession) {
-  const normalizedQuestion = normalize(question);
-  const partA = parsePart(normalizedQuestion.partA, 'partA', session, env);
-  const partB = parsePart(normalizedQuestion.partB, 'partB', session, env);
-
-  const shuffledValues = {};
-
-  const us = (part) => (id, element, update) =>
-    new Promise((resolve) => {
-      shuffledValues[part] = update.shuffledValues;
-      resolve();
-    });
-
-  const partASession = get(session, 'value.partA');
-  const partALockChoiceOrder = lockChoices(normalizedQuestion.partA, partASession, env);
-
-  const { choices: partAChoices } = partA || {};
-  const { choices: partBChoices } = partB || {};
-
-  if (!partALockChoiceOrder && partAChoices && partAChoices.length) {
-    partA.choices = await getShuffledChoices(
-      partAChoices,
-      { shuffledValues: (session.shuffledValues || {}).partA },
-      us('partA'),
-      'value',
-    );
-  }
-
-  const partBSession = get(session, 'value.partB');
-  const partBLockChoiceOrder = lockChoices(normalizedQuestion.partB, partBSession, env);
-
-  if (!partBLockChoiceOrder && partBChoices && partBChoices.length) {
-    partB.choices = await getShuffledChoices(
-      partBChoices,
-      { shuffledValues: (session.shuffledValues || {}).partB },
-      us('partB'),
-      'value',
-    );
-  }
-
-  if (!isEmpty(shuffledValues)) {
-    if (updateSession && typeof updateSession === 'function') {
-      updateSession(session.id, session.element, {
-        shuffledValues,
-      }).catch((e) => {
-        // eslint-disable-next-line no-console
-        console.error('update session failed', e);
-      });
-    }
-  }
-
-  if (normalizedQuestion.partLabels) {
-    const language = normalizedQuestion.language;
-    partA.partLabel = translator.t('ebsr.part', {
-      lng: language,
-      index: normalizedQuestion.partLabelType === 'Letters' ? 'A' : '1',
-    });
-    partB.partLabel = translator.t('ebsr.part', {
-      lng: language,
-      index: normalizedQuestion.partLabelType === 'Letters' ? 'B' : '2',
-    });
-  } else {
-    partA.partLabel = undefined;
-    partB.partLabel = undefined;
-  }
-
-  if (env.role === 'instructor' && (env.mode === 'view' || env.mode === 'evaluate')) {
-    partA.teacherInstructions = normalizedQuestion.partA.teacherInstructionsEnabled
-      ? normalizedQuestion.partA.teacherInstructions
-      : null;
-    partB.teacherInstructions = normalizedQuestion.partB.teacherInstructionsEnabled
-      ? normalizedQuestion.partB.teacherInstructions
-      : null;
-  } else {
-    partA.teacherInstructions = null;
-    partB.teacherInstructions = null;
-  }
-
-  partA.prompt = normalizedQuestion.partA.promptEnabled ? normalizedQuestion.partA.prompt : null;
-  partB.prompt = normalizedQuestion.partB.promptEnabled ? normalizedQuestion.partB.prompt : null;
-
-  return new Promise((resolve) => {
-    resolve({
-      disabled: env.mode !== 'gather',
-      mode: env.mode,
-      extraCSSRules: normalizedQuestion.extraCSSRules,
-      partA,
-      partB,
-    });
-  });
-}
-
-export const createDefaultModel = (model = {}) =>
-  new Promise((resolve) => {
-    resolve({
-      ...defaults,
-      ...model,
-    });
-  });
-
-const isCorrect = (c) => c.correct === true;
-
-const getScore = (config, sessionPart, key, partialScoringEnabled) => {
-  const { choices = [] } = (config && config[key]) || {};
-  const maxScore = choices.length;
-  const { value: sessionPartValue } = sessionPart || {};
-
-  const chosen = (c) => !!(sessionPartValue || []).find((v) => v === c.value);
-  const correctAndNotChosen = (c) => isCorrect(c) && !chosen(c);
-  const incorrectAndChosen = (c) => !isCorrect(c) && chosen(c);
-  const correctChoices = choices.reduce((total, choice) => {
-    if (correctAndNotChosen(choice) || incorrectAndChosen(choice)) {
-      return total - 1;
-    } else {
-      return total;
-    }
-  }, choices.length);
-
-  // determine score for a part
-  if (!partialScoringEnabled && correctChoices < maxScore) {
-    return 0;
-  }
-
-  return parseFloat(maxScore ? (correctChoices / maxScore).toFixed(2) : 0);
-};
-
-/**
- * Generates detailed trace log for math-templated scoring evaluation
- * @param {Object} question
- * @param {Object} session
- * @param {Object} env
- * @returns {Array<string>} traceLog
- */
-export const getLogTrace = (question, session, env) => {
-  const traceLog = [];
-
-  if (!session || !session.value) {
-    traceLog.push('Student did not answer the question.');
-    return traceLog;
-  }
-
-  const { value } = session;
-  const { partA, partB } = value;
-
-  const partialScoringEnabled = partialScoring.enabled(question, env);
-
-  traceLog.push(
-    `Scoring method: ${partialScoringEnabled ? 'partial scoring' : 'all-or-nothing scoring'}.`
-  );
-
-  const partAquestionType =
-    question.partA.choiceMode === 'radio'
-      ? 'multiple-choice (radio)'
-      : 'multiple-select (checkbox)';
-  traceLog.push(`Part A question type: ${partAquestionType}.`);
-
-  const partASelections = partA?.value || [];
-  const partACorrectChoices = (question.partA.choices || []).filter((c) => c.correct);
-  const partACorrectValues = partACorrectChoices.map((c) => c.value);
-  const partACorrectSelected = partASelections.filter((v) => partACorrectValues.includes(v));
-  const partAIncorrectSelected = partASelections.filter((v) => !partACorrectValues.includes(v));
-
-  if (partASelections.length) {
-    traceLog.push(
-      `Part A: student selected ${partASelections.length} choice(s) (${partACorrectSelected.length} correct, ${partAIncorrectSelected.length} incorrect).`
-    );
-  }
-  
-  const scoreA = getScore(question, partA, 'partA', partialScoringEnabled);
-  traceLog.push(`Part A score: ${scoreA}.`);
-
-  const partBquestionType =
-    question.partB.choiceMode === 'radio'
-      ? 'multiple-choice (radio)'
-      : 'multiple-select (checkbox)';
-  traceLog.push(`Part B question type: ${partBquestionType}.`);
-
-  const partBSelections = partB?.value || [];
-  const partBCorrectChoices = (question.partB.choices || []).filter((c) => c.correct);
-  const partBCorrectValues = partBCorrectChoices.map((c) => c.value);
-  const correctSelected = partBSelections.filter((v) => partBCorrectValues.includes(v));
-  const incorrectSelected = partBSelections.filter((v) => !partBCorrectValues.includes(v));
-
-  if (partBSelections.length) {
-    traceLog.push(
-      `Part B: student selected ${partBSelections.length} choice(s) (${correctSelected.length} correct, ${incorrectSelected.length} incorrect).`
-    );
-  }
-
-  const scoreB = getScore(question, partB, 'partB', partialScoringEnabled);
-  traceLog.push(`Part B score: ${scoreB}.`);
-
-  if (!partialScoringEnabled) {
-    traceLog.push(
-      'Final score is awarded only if both Part A and Part B are completely correct.'
-    );
-    traceLog.push(`Final score: ${scoreA === 1 && scoreB === 1 ? 1 : 0}.`);
-  } else {
-    traceLog.push(
-      'With partial scoring enabled, Part A must be correct to earn any credit.'
-    );
-
-    let finalScore = 0;
-    if (scoreA === 1 && scoreB === 1) {
-      finalScore = 2;
-    } else if (scoreA === 1 && scoreB < 1) {
-      finalScore = 1;
-    }
-
-    traceLog.push(`Final score: ${finalScore}.`);
-  }
-
-  return traceLog;
-};
-
-export function outcome(config, session, env) {
-  return new Promise((resolve) => {
-    const { value } = session || {};
-
-    if (!session || !value) {
-      resolve({ score: 0, scoreA: 0, scoreB: 0, empty: true, logTrace: ['Student did not answer the question.'] });
-    }
-
-    if (value) {
-      const { partA, partB } = value || {};
-
-      const partialScoringEnabled = partialScoring.enabled(config, env);
-
-      const scoreA = getScore(config, partA, 'partA', partialScoringEnabled);
-      const scoreB = getScore(config, partB, 'partB', partialScoringEnabled);
-      const logTrace = getLogTrace(config, session, env);
-
-      if (!partialScoringEnabled) {
-        // The EBSR item is worth 1 point
-        // That point is awarded if and only if both parts are fully correct, otherwise no points are awarded
-        resolve({ score: scoreA === 1 && scoreB === 1 ? 1 : 0, scoreA, scoreB, max: 1, logTrace });
-      } else {
-        // The EBSR item is worth 2 points
-        if (scoreA === 1) {
-          if (scoreB === 1) {
-            // If Part A and Part B are both correct, 2 points are awarded
-            resolve({ score: 2, scoreA, scoreB, max: 2, logTrace });
-          } else {
-            // If Part A is correct and part B is incorrect, 1 point is awarded
-            resolve({ score: 1, scoreA, scoreB, max: 2, logTrace });
-          }
-        } else {
-          // For all other combinations, no points are awarded
-          resolve({ score: 0, scoreA, scoreB, max: 2, logTrace });
-        }
-      }
-    }
-  });
-}
-
-const returnPartCorrect = (choices) => {
-  let answers = [];
-
-  choices.forEach((i) => {
-    const { correct, value } = i;
-    if (correct) {
-      answers.push(value);
-    }
-  });
-  return answers;
-};
-
-export const createCorrectResponseSession = (question, env) => {
-  return new Promise((resolve) => {
-    if (env.mode !== 'evaluate' && env.role === 'instructor') {
-      const { partA, partB } = question;
-
-      const partACorrect = returnPartCorrect(partA.choices);
-      const partBCorrect = returnPartCorrect(partB.choices);
-
-      resolve({
-        value: {
-          partA: {
-            id: 'partA',
-            value: partACorrect,
-          },
-          partB: {
-            id: 'partB',
-            value: partBCorrect,
-          },
-        },
-        id: '1',
-      });
-    } else {
-      resolve(null);
-    }
-  });
-};
-
-// remove all html tags
-const getInnerText = (html) => (html || '').replaceAll(/<[^>]*>/g, '');
-
-// remove all html tags except img, iframe and source tag for audio
-const getContent = (html) => (html || '').replace(/(<(?!img|iframe|source)([^>]+)>)/gi, '');
-
-const validatePart = (model = {}, config = {}) => {
-  const { choices } = model;
-  const { minAnswerChoices = 2, maxAnswerChoices } = config;
-  const reversedChoices = [...(choices || [])].reverse();
-  const errors = {};
-  const choicesErrors = {};
-  const rationaleErrors = {};
-  let hasCorrectResponse = false;
-
-  ['teacherInstructions', 'prompt'].forEach((field) => {
-    if (config[field]?.required && !getContent(model[field])) {
-      errors[field] = 'This field is required.';
-    }
-  });
-
-  reversedChoices.forEach((choice, index) => {
-    const { correct, value, label, rationale } = choice;
-
-    if (correct) {
-      hasCorrectResponse = true;
-    }
-
-    if (!getContent(label)) {
-      choicesErrors[value] = 'Content should not be empty.';
-    } else {
-      const identicalAnswer = reversedChoices.slice(index + 1).some((c) => c.label === label);
-
-      if (identicalAnswer) {
-        choicesErrors[value] = 'Content should be unique.';
-      }
-    }
-
-    if (config.rationale?.required && !getContent(rationale)) {
-      rationaleErrors[value] = 'This field is required.';
-    }
-  });
-
-  const nbOfChoices = (choices || []).length;
-
-  if (nbOfChoices < minAnswerChoices) {
-    errors.answerChoices = `There should be at least ${minAnswerChoices} choices defined.`;
-  } else if (nbOfChoices > maxAnswerChoices) {
-    errors.answerChoices = `No more than ${maxAnswerChoices} choices should be defined.`;
-  }
-
-  if (!hasCorrectResponse) {
-    errors.correctResponse = 'No correct response defined.';
-  }
-
-  if (!isEmpty(choicesErrors)) {
-    errors.choices = choicesErrors;
-  }
-
-  if (!isEmpty(rationaleErrors)) {
-    errors.rationale = rationaleErrors;
-  }
-
-  return errors;
-};
-
-export const validate = (model = {}, config = {}) => {
-  const { partA, partB } = model || {};
-  const { partA: partAConfig, partB: partBConfig } = config || {};
-
-  const partAErrors = validatePart(partA, partAConfig);
-  const partBErrors = validatePart(partB, partBConfig);
-
-  return { partA: partAErrors, partB: partBErrors };
-};

package/controller/src/utils.js

@@ -1,18 +0,0 @@
-import { isEqual } from 'lodash-es';
-
-export const getCorrectResponse = (choices) =>
-  choices &&
-  choices
-    .filter((c) => c.correct)
-    .map((c) => c.value)
-    .sort();
-
-export const isResponseCorrect = (question, key, session) => {
-  let correctResponse = getCorrectResponse(question.choices);
-
-  if (session && session.value) {
-    return isEqual((session.value[key].value || []).sort(), correctResponse);
-  }
-
-  return false;
-};