@pie-element/complex-rubric 2.2.0-next.1 → 2.2.1-next.12

package/module/controller.js

@@ -0,0 +1,375 @@
+const multiTraitDefaultModel = {
+  visibleToStudent: true,
+  halfScoring: false,
+  pointLabels: true,
+  description: false,
+  standards: false,
+  scales: [],
+  excludeZero: false,
+};
+
+const rubricDefaultModel = {
+  points: ['', '', '', ''],
+  sampleAnswers: [null, null, null, null],
+  maxPoints: 4,
+  excludeZero: false,
+};
+
+const rubriclessDefaultModel = {
+  maxPoints: 100,
+  excludeZero: false,
+  rubriclessInstructionEnabled: true,
+};
+
+const multiTraitDefaultConfiguration = {
+  settingsPanelDisabled: false,
+  excludeZeroDialogBoxContent: {
+    title: 'Exclude 0 (Zero) from Score Point Values.',
+    text: `<div>
+        You are about to exclude 0 from score point values.
+        <br/>
+        Some of the existing data has to be changed.
+        <br/>
+        Please choose if you want to:
+        <ul>
+          <li>
+            shift Labels and Descriptions to the left
+          </li>
+          <li>
+            remove 0 column with its Label and Description
+          </li>
+        </ul>
+      </div>`,
+  },
+  includeZeroDialogBoxContent: {
+    title: 'Include 0 (Zero) in Score Point Values.',
+    text: `<div>
+        You are about to include 0 in score point values.
+        <br/>
+        Some of the existing data has to be changed.
+        <br/>
+        Please choose if you want to:
+        <ul>
+          <li>
+            shift Labels and Descriptions to the right
+          </li>
+          <li>
+            add 0 column with empty Label and Descriptions
+          </li>
+        </ul>
+      </div>`,
+  },
+  deleteScaleDialogBoxContent: {
+    title: 'Delete Scale',
+    text: 'Are you sure you want to delete this scale?',
+  },
+  maxPointsDialogBoxContent: {
+    title: 'Decreasing Max Points.',
+    text: ` You are about to decrease max score point value.
+        <br/>
+        All the Labels and Descriptions for scores above Max Point will be deleted.`,
+  },
+  spellCheck: {
+    label: 'Spellcheck',
+    settings: false,
+    enabled: true,
+  },
+  showExcludeZero: {
+    settings: true,
+    label: 'Exclude Zero',
+  },
+  showScorePointLabels: {
+    settings: true,
+    label: 'Show Score Point Labels',
+  },
+  showDescription: {
+    settings: true,
+    label: 'Show Description',
+  },
+  showVisibleToStudent: {
+    settings: true,
+    label: 'Visible to Student',
+  },
+  showHalfScoring: {
+    settings: true,
+    label: 'Half Scoring',
+  },
+  width: '900px',
+  // these should not be set to true (should not be used) for now
+  showStandards: {
+    settings: false,
+    label: 'Show Standards',
+  },
+  showLevelTagInput: {
+    settings: false,
+    label: 'Show Level Tag Input',
+    enabled: false,
+  },
+  dragAndDrop: {
+    settings: true,
+    label: 'Enable Drag and Drop',
+    enabled: false,
+  },
+};
+
+const rubricDefaultConfiguration = {
+  showExcludeZero: {
+    settings: true,
+    label: 'Ability to exclude zero',
+  },
+  showMaxPoint: {
+    settings: true,
+    label: 'Show max points dropdown',
+  },
+  settingsPanelDisabled: false,
+};
+
+const rubriclessDefaultConfiguration = {
+  showExcludeZero: {
+    settings: true,
+    label: 'Ability to exclude zero',
+  },
+  showMaxPoint: {
+    settings: true,
+    label: 'Show max points dropdown',
+  },
+  settingsPanelDisabled: false,
+  // shows us if it simple rubric or rubricless(simple rubric with less structure)
+  rubricless: true,
+  // scoring instruction for rubricless
+  rubriclessInstruction: {
+    settings: true,
+    label: 'Instruction',
+  },
+  maxMaxPoints: 100,
+};
+
+var defaults = {
+  model: {
+    rubricOptions: ['simpleRubric', 'multiTraitRubric'],
+    rubricType: 'simpleRubric',
+    rubrics: { simpleRubric: rubricDefaultModel, multiTraitRubric: multiTraitDefaultModel, rubricless: rubriclessDefaultModel },
+  },
+  configuration: {
+    multiTraitRubric: multiTraitDefaultConfiguration,
+    simpleRubric: rubricDefaultConfiguration,
+    rubricless: rubriclessDefaultConfiguration,
+  },
+};
+
+const markupToText = (s) => {
+    return (s || '').replace(/(<([^>]+)>)/ig, '');
+};
+
+// todo the import from pie-lib/rubric might break webpack
+const RUBRIC_TYPES = {
+  SIMPLE_RUBRIC: 'simpleRubric',
+  MULTI_TRAIT_RUBRIC: 'multiTraitRubric',
+  'rubricless': 'rubricless',
+};
+
+function createDefaultModel(model = {}) {
+  return new Promise((resolve) => resolve({ ...defaults.model, ...model }));
+}
+
+const normalize = (question) => ({ ...defaults.model, ...question });
+
+/**
+ * @param {*} question
+ * @param {*} session
+ * @param {*} env
+ */
+async function model(question, session, env) {
+  const normalizedQuestion = normalize(question);
+
+  if (normalizedQuestion.rubricType === RUBRIC_TYPES.SIMPLE_RUBRIC || normalizedQuestion.rubricType === 'rubricless') {
+    return new Promise((resolve) => {
+      resolve(
+        env && env.role && env.role === 'instructor'
+          ? {
+            ...normalizedQuestion,
+            rubrics: {
+              ...normalizedQuestion.rubrics,
+              multiTraitRubric: {
+                ...normalizedQuestion.rubrics.multiTraitRubric,
+                visible: false,
+              },
+            },
+          }
+          : {},
+      );
+    });
+  } else {
+    if (
+      !env.role ||
+      (env.role === 'student' && normalizedQuestion.rubrics && normalizedQuestion.rubrics.multiTraitRubric)
+    ) {
+      normalizedQuestion.rubrics.multiTraitRubric.visible = normalizedQuestion.visibleToStudent;
+    } else {
+      normalizedQuestion.rubrics.multiTraitRubric.visible = true;
+    }
+
+    // todo update pie-ui instead of parsing this here:
+    const { scales, excludeZero } = normalizedQuestion.rubrics.multiTraitRubric || {};
+    const parsedScales = (scales || []).map((scale) => ({ ...scale, excludeZero }));
+
+    return {
+      ...normalizedQuestion,
+      rubrics: {
+        ...normalizedQuestion.rubrics,
+        simpleRubric: {
+          ...normalizedQuestion.rubrics.simpleRubric,
+          visible: false,
+        },
+        rubricless: {
+          ...normalizedQuestion.rubrics.rubricless,
+          visible: false,
+        },
+        multiTraitRubric: {
+          ...normalizedQuestion.rubrics.multiTraitRubric,
+          scales: parsedScales,
+        },
+      },
+    };
+  }
+}
+
+const getScore = () => 0;
+
+/**
+ * @param {Object} model - the main model
+ * @param {*} session
+ * @param {Object} env
+ */
+function outcome() {
+  return new Promise((resolve) => resolve({ score: 0, empty: true }));
+}
+
+const createCorrectResponseSession = (question, env) => {
+  return new Promise((resolve) => {
+    if (env.mode !== 'evaluate' && env.role === 'instructor') {
+      resolve({ id: '1' });
+    } else {
+      resolve(null);
+    }
+  });
+};
+
+// IMPORTANT! This function is a duplicate of rubric/controller/validate function!
+// If you make any changes to this function, please make sure you also update rubric/controller/validate function!“.
+const validateSimpleRubric = (model) => {
+  const { points } = model;
+  const errors = {};
+  const pointsDescriptorsErrors = {};
+
+  (points || []).forEach((point, index) => {
+    if(!point|| point === '<div></div>') {
+      pointsDescriptorsErrors[index] = 'Points descriptors cannot be empty.';
+    }
+    else {
+      const identicalPointDescr = points.slice(index + 1).some(p => markupToText(p) === markupToText(point));
+
+      if (identicalPointDescr) {
+        pointsDescriptorsErrors[index] = 'Points descriptors should be unique.';
+      }
+    }
+  });
+
+  if(Object.keys(pointsDescriptorsErrors).length > 0){
+    errors.pointsDescriptorsErrors = pointsDescriptorsErrors;
+  }
+
+  return errors;
+};
+
+// IMPORTANT! This function is a duplicate of multi-trait-rubric/controller/validate function!
+// If you make any changes to this function, please make sure you also update multi-trait-rubric/controller/validate function!“.
+const validateMultiTraitRubric = (model) => {
+  const { scales, description = false, pointLabels = false } = model;
+  const errors = {};
+  const traitsErrors = {};
+  const scorePointsErrors = {};
+
+  (scales || []).forEach((scale, scaleIndex) => {
+    const { traits = [] } = scale;
+    const { scorePointsLabels = [] } = scale;
+    const scaleErrors = {};
+    const scorePointsLabelsErrors = {};
+
+    if(pointLabels) {
+      scorePointsLabels.forEach((scorePointLabel, scoreIndex) => {
+        if (!scorePointLabel || scorePointLabel === '<div></div>') {
+          scorePointsLabelsErrors[scoreIndex] = 'Points labels should not be empty.';
+        } else {
+          const identicalScorePointLabel = scorePointsLabels.slice(scoreIndex + 1).some(s => markupToText(s) === markupToText(scorePointLabel));
+
+          if (identicalScorePointLabel) {
+            scorePointsLabelsErrors[scoreIndex] = 'Points labels should be unique.';
+          }
+        }
+      });
+    }
+
+    if(Object.keys(scorePointsLabelsErrors).length > 0){
+      scorePointsErrors[scaleIndex] = scorePointsLabelsErrors;
+    }
+
+    traits.forEach((trait, traitIndex) => {
+      if(!trait.name || trait.name === '<div></div>') {
+        scaleErrors[traitIndex] = {name: 'Trait names should not be empty.'};
+      }
+      else {
+        const identicalTraitName = traits.slice(traitIndex + 1).some(t => markupToText(t.name) === markupToText(trait.name));
+
+        if (identicalTraitName) {
+          scaleErrors[traitIndex] = {name: 'Trait names should be unique.'};
+        }
+      }
+      if(description && (!trait.description || trait.description === '<div></div>')) {
+        scaleErrors[traitIndex] = {... scaleErrors[traitIndex], description: 'Trait description should not be empty'};
+      }
+      else {
+        const identicalTraitDescr = traits.slice(traitIndex + 1).some(t => markupToText(t.description) === markupToText(trait.description));
+
+        if (description && identicalTraitDescr) {
+          scaleErrors[traitIndex] = {... scaleErrors[traitIndex], description: 'Trait descriptions should be unique.'};
+        }
+      }
+
+    });
+    if(Object.keys(scaleErrors).length > 0){
+      traitsErrors[scaleIndex] = scaleErrors;
+    }
+  });
+
+  if(Object.keys(traitsErrors).length > 0){
+    errors.traitsErrors = traitsErrors;
+  }
+
+  if(Object.keys(scorePointsErrors).length > 0){
+    errors.scorePointsErrors = scorePointsErrors;
+  }
+
+  return errors;
+};
+
+
+const validate = (model = {}, config = {}) => {
+  const { rubrics = {}, rubricType } = model;
+  const { multiTraitRubric = {}, simpleRubric = {} } = rubrics;
+  let errors = {};
+
+  switch (rubricType) {
+    case RUBRIC_TYPES.SIMPLE_RUBRIC:
+    default:
+      errors = validateSimpleRubric(simpleRubric);
+      break;
+    case RUBRIC_TYPES.MULTI_TRAIT_RUBRIC:
+      errors = validateMultiTraitRubric(multiTraitRubric);
+      break;
+  }
+
+  return errors;
+};
+
+export { createCorrectResponseSession, createDefaultModel, getScore, model, normalize, outcome, validate };

package/module/demo.js

@@ -8,7 +8,7 @@ generate.model = (id, element) => ({
   id,
   element,
   rubricType: 'simpleRubric',
-  rubricOptions: ['simpleRubric', 'multiTraitRubric', 'rubricless'],
+  rubricOptions: ['simpleRubric', 'multiTraitRubric'],
   rubrics: {
     simpleRubric: {
       points: ['nothing right', 'a teeny bit right', 'mostly right', 'bingo'],