@instructure/quiz-core 17.19.2 → 17.20.0

package/lib/common/records/QuizSession.js

@@ -0,0 +1,219 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.QuizSession = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+
+var _immutable = require("immutable");
+
+var _reduxRecord = _interopRequireDefault(require("./reduxRecord.js"));
+
+var _QuizSessionEvent = _interopRequireDefault(require("./QuizSessionEvent.js"));
+
+var _quizCommon = require("@instructure/quiz-common");
+
+var _quizzes = require("../selectors/quizzes.js");
+
+var _quizSessionResults = require("../selectors/quizSessionResults.js");
+
+var _taking = require("../selectors/taking.js");
+
+var _sessionItems = require("../selectors/sessionItems.js");
+
+var QuizSession = /*#__PURE__*/function (_ReduxRecord) {
+  (0, _inherits2.default)(QuizSession, _ReduxRecord);
+
+  var _super = (0, _createSuper2.default)(QuizSession);
+
+  function QuizSession() {
+    (0, _classCallCheck2.default)(this, QuizSession);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(QuizSession, [{
+    key: "isLoaded",
+    // Helpers
+    value: function isLoaded() {
+      return this.id !== '0';
+    }
+  }, {
+    key: "isOneQuestionAtATime",
+    value: function isOneQuestionAtATime() {
+      return this.oneAtATimeType === 'question';
+    } // Status helpers
+
+  }, {
+    key: "pending",
+    value: function pending() {
+      return this.status === _quizCommon.PENDING;
+    }
+  }, {
+    key: "starting",
+    value: function starting() {
+      return this.status === _quizCommon.STARTING;
+    }
+  }, {
+    key: "creatingSessionItems",
+    value: function creatingSessionItems() {
+      return this.status === _quizCommon.CREATING_SESSION_ITEMS;
+    }
+  }, {
+    key: "failedToStart",
+    value: function failedToStart() {
+      return this.status === _quizCommon.FAILED_TO_START;
+    }
+  }, {
+    key: "inProgress",
+    value: function inProgress() {
+      return this.status === _quizCommon.IN_PROGRESS;
+    }
+  }, {
+    key: "reopeningGraded",
+    value: function reopeningGraded() {
+      return this.status === _quizCommon.REOPENING_GRADED;
+    }
+  }, {
+    key: "creatingResponses",
+    value: function creatingResponses() {
+      return this.status === _quizCommon.CREATING_RESPONSES;
+    }
+  }, {
+    key: "autoGrading",
+    value: function autoGrading() {
+      return this.status === _quizCommon.AUTOGRADING;
+    }
+  }, {
+    key: "needsGrading",
+    value: function needsGrading() {
+      return this.status === _quizCommon.NEEDS_GRADING;
+    }
+  }, {
+    key: "failed",
+    value: function failed() {
+      return this.status === _quizCommon.FAILURE;
+    }
+  }, {
+    key: "graded",
+    value: function graded() {
+      return this.status === _quizCommon.GRADED;
+    }
+  }, {
+    key: "taking",
+    value: function taking() {
+      return this.starting() || this.creatingSessionItems() || this.inProgress() || this.reopeningGraded();
+    }
+  }, {
+    key: "submitted",
+    value: function submitted() {
+      return this.creatingResponses() || this.autoGrading() || this.needsGrading() || this.graded() || this.failed();
+    }
+  }, {
+    key: "pins",
+    value: function pins() {
+      return this.takingData.get('pins') || (0, _immutable.List)();
+    }
+  }, {
+    key: "timeAllowed",
+    value: function timeAllowed() {
+      return this.takingData.get('timeAllowed');
+    } // Relationships
+
+  }, {
+    key: "getQuiz",
+    value: function getQuiz() {
+      return (0, _quizzes.getQuizById)(this.getState(), this.quiz);
+    }
+  }, {
+    key: "getSessionItems",
+    value: function getSessionItems() {
+      return (0, _sessionItems.getSessionItemsByIds)(this.getState(), this.sessionItems);
+    }
+  }, {
+    key: "getQuizSessionResults",
+    value: function getQuizSessionResults() {
+      return (0, _quizSessionResults.getQuizSessionResultsByIds)(this.getState(), this.quizSessionResults);
+    }
+  }, {
+    key: "getResumeData",
+    value: function getResumeData() {
+      return (0, _taking.getResponsesByIds)(this.getState(), this.resumeData);
+    }
+  }, {
+    key: "getEvents",
+    value: function getEvents() {
+      return this.getState().getIn(['quizSessionEvents', this.id], (0, _immutable.List)()).map(function (data) {
+        return new _QuizSessionEvent.default(data);
+      });
+    }
+  }, {
+    key: "findAuthoritativeResult",
+    value: function findAuthoritativeResult() {
+      return (0, _quizSessionResults.getQuizSessionResultById)(this.getState(), this.authoritativeResult);
+    }
+  }, {
+    key: "userDisplayName",
+    value: function userDisplayName() {
+      // Still accurate?
+      var email, fullName, givenName;
+
+      if (this.user) {
+        var _this$user$toJS = this.user.toJS();
+
+        email = _this$user$toJS.email;
+        fullName = _this$user$toJS.fullName;
+        givenName = _this$user$toJS.givenName;
+      }
+
+      return fullName || givenName || email || '';
+    }
+  }, {
+    key: "hasTimeAllowed",
+    get: function get() {
+      return typeof this.timeAllowed() === 'number';
+    }
+  }]);
+  return QuizSession;
+}((0, _reduxRecord.default)({
+  acceptedStudentAccessCode: false,
+  accountUuid: '',
+  rootAccountUuid: '',
+  allowBacktracking: true,
+  authoritativeResult: null,
+  disableTimer: false,
+  dueAt: null,
+  elapsedTime: null,
+  endAt: null,
+  eventCreationToken: null,
+  extraTimeInSeconds: null,
+  id: '0',
+  ipIsAllowed: null,
+  kinesisCredentials: {},
+  oneAtATimeType: null,
+  quiz: null,
+  // this is really a quizId
+  quizSessionResults: (0, _immutable.List)(),
+  resumeData: (0, _immutable.List)(),
+  sessionItems: (0, _immutable.List)(),
+  sessionItemsCount: null,
+  startAt: null,
+  status: '',
+  takingData: (0, _immutable.Map)(),
+  timerMultiplier: null,
+  user: (0, _immutable.Map)() // Good candidate for another Record - Still relevant?
+
+}));
+
+exports.QuizSession = QuizSession;
+var _default = QuizSession;
+exports.default = _default;

package/lib/common/records/QuizSessionEvent.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.QuizSessionEvent = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+
+var _reduxRecord = _interopRequireDefault(require("./reduxRecord.js"));
+
+var _sessionItems = require("../selectors/sessionItems.js");
+
+var QuizSessionEvent = /*#__PURE__*/function (_ReduxRecord) {
+  (0, _inherits2.default)(QuizSessionEvent, _ReduxRecord);
+
+  var _super = (0, _createSuper2.default)(QuizSessionEvent);
+
+  function QuizSessionEvent() {
+    (0, _classCallCheck2.default)(this, QuizSessionEvent);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(QuizSessionEvent, [{
+    key: "isLoaded",
+    value: function isLoaded() {
+      return !!this.get('createdAt');
+    }
+  }, {
+    key: "createdDate",
+    value: function createdDate() {
+      return new Date(this.get('createdAt').split('|')[0]);
+    }
+  }, {
+    key: "getSessionItem",
+    value: function getSessionItem() {
+      var sessionItemPosition = Math.round(this.getIn(['eventData', 'position']));
+      var sessionItemKey = "".concat(this.quizSessionId, "_").concat(sessionItemPosition);
+      return (0, _sessionItems.getSessionItemById)(this.getState(), sessionItemKey);
+    }
+  }, {
+    key: "getItem",
+    value: function getItem() {
+      return this.getSessionItem().getItem();
+    }
+  }]);
+  return QuizSessionEvent;
+}((0, _reduxRecord.default)({
+  createdAt: null,
+  eventType: null,
+  eventData: null,
+  quizSessionId: null
+}));
+
+exports.QuizSessionEvent = QuizSessionEvent;
+var _default = QuizSessionEvent;
+exports.default = _default;

package/lib/common/records/QuizSessionResult.js

@@ -0,0 +1,90 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.QuizSessionResult = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+
+var _immutable = require("immutable");
+
+var _reduxRecord = _interopRequireDefault(require("./reduxRecord.js"));
+
+var _quizCommon = require("@instructure/quiz-common");
+
+var _sessionItemResults = require("../selectors/sessionItemResults.js");
+
+var QuizSessionResult = /*#__PURE__*/function (_ReduxRecord) {
+  (0, _inherits2.default)(QuizSessionResult, _ReduxRecord);
+
+  var _super = (0, _createSuper2.default)(QuizSessionResult);
+
+  function QuizSessionResult() {
+    (0, _classCallCheck2.default)(this, QuizSessionResult);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(QuizSessionResult, [{
+    key: "isGraded",
+    value: function isGraded() {
+      return this.status === 'graded' || this.autogradingFailed();
+    }
+  }, {
+    key: "autogradingFailed",
+    value: function autogradingFailed() {
+      return this.status === 'autograding_failed';
+    }
+  }, {
+    key: "isLoaded",
+    value: function isLoaded() {
+      return this.id !== '0';
+    }
+  }, {
+    key: "getSessionItemResults",
+    value: function getSessionItemResults() {
+      return (0, _sessionItemResults.getSessionItemResultsByIds)(this.getState(), this.sessionItemResults);
+    }
+  }, {
+    key: "getWorkingInstance",
+    value: function getWorkingInstance() {
+      var mods = this.getState().getIn(['modifications', 'quizSessionResults', this.id]);
+      return QuizSessionResult.create(this.merge(mods));
+    }
+  }, {
+    key: "hasModifications",
+    value: function hasModifications() {
+      return !(0, _immutable.is)(this.getWorkingInstance(), this);
+    }
+  }], [{
+    key: "fetcherTag",
+    value: function fetcherTag(id) {
+      return "".concat(_quizCommon.QUIZ_SESSION_RESULT_FETCH_CALL, "_").concat(id);
+    }
+  }]);
+  return QuizSessionResult;
+}((0, _reduxRecord.default)({
+  createdAt: null,
+  fudgePoints: null,
+  gradingMethod: null,
+  id: '0',
+  percentage: null,
+  pointsPossible: null,
+  quizSession: null,
+  score: null,
+  sessionItemResults: (0, _immutable.List)(),
+  status: null,
+  updatedAt: null
+}));
+
+exports.QuizSessionResult = QuizSessionResult;
+var _default = QuizSessionResult;
+exports.default = _default;

package/lib/common/records/Response.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.Response = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+
+var _reduxRecord = _interopRequireDefault(require("./reduxRecord.js"));
+
+var _instructureValidations = require("instructure-validations");
+
+var _quizCommon = require("@instructure/quiz-common");
+
+var _sessionItems = require("../selectors/sessionItems.js");
+
+var Response = /*#__PURE__*/function (_ReduxRecord) {
+  (0, _inherits2.default)(Response, _ReduxRecord);
+
+  var _super = (0, _createSuper2.default)(Response);
+
+  function Response() {
+    (0, _classCallCheck2.default)(this, Response);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(Response, [{
+    key: "getItem",
+    value: function getItem() {
+      if (this.itemId) {
+        return (0, _sessionItems.getSessionItemById)(this.getState(), this.id).getItem();
+      }
+    }
+  }], [{
+    key: "validations",
+    value: function validations() {
+      return {
+        userResponse: [(0, _instructureValidations.rule)('maxContent', {
+          limit: _quizCommon.TAKE_CHAR_LIMIT
+        })]
+      };
+    }
+  }]);
+  return Response;
+}((0, _reduxRecord.default)({
+  attempt: null,
+  itemId: null,
+  largeFormatResponse: null,
+  position: null,
+  userResponse: null,
+  id: null
+}));
+
+exports.Response = Response;
+var _default = Response;
+exports.default = _default;

package/lib/common/records/SessionItem.js

@@ -0,0 +1,150 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.SessionItem = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+
+var _immutable = require("immutable");
+
+var _reduxRecord = _interopRequireDefault(require("./reduxRecord.js"));
+
+var _Item = _interopRequireDefault(require("./Item.js"));
+
+var _Stimulus = _interopRequireDefault(require("./Stimulus.js"));
+
+var _SessionItemResult = _interopRequireDefault(require("./SessionItemResult.js"));
+
+var SessionItem = /*#__PURE__*/function (_ReduxRecord) {
+  (0, _inherits2.default)(SessionItem, _ReduxRecord);
+
+  var _super = (0, _createSuper2.default)(SessionItem);
+
+  function SessionItem() {
+    (0, _classCallCheck2.default)(this, SessionItem);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(SessionItem, [{
+    key: "getItem",
+    value: function getItem() {
+      if (this.item) {
+        return _Item.default.create(this.item);
+      }
+    }
+  }, {
+    key: "getEntry",
+    value: function getEntry() {
+      return {
+        Stimulus: this.stimulusRecord,
+        Item: this.itemRecord
+      }[this.type];
+    }
+  }, {
+    key: "getNestedEntries",
+    value: function getNestedEntries() {
+      var _this = this;
+
+      var fromState = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
+
+      if (this.stimulus) {
+        if (this.items && !fromState) {
+          return this.items;
+        }
+
+        var stimulusIdFilter = function stimulusIdFilter(si) {
+          return si.get('quizSessionId') === _this.quizSessionId && si.getIn(['stimulus', 'id']) === _this.getIn(['stimulus', 'id']);
+        };
+
+        var stimulusKeyFilter = function stimulusKeyFilter(si) {
+          return si.get('quizSessionId') === _this.quizSessionId && si.get('stimulusKey') === _this.stimulusKey;
+        }; // fallback to use the stimulus id when stimulusKey is not present
+
+
+        var filter = this.stimulusKey === null ? stimulusIdFilter : stimulusKeyFilter;
+        this.items = this.getState().get('sessionItems').filter(filter).map(function (si) {
+          return SessionItem.create(si);
+        }).sortBy(function (si) {
+          return si.position;
+        }).toList();
+        return this.items;
+      }
+
+      return (0, _immutable.List)();
+    }
+  }, {
+    key: "sessionItemResult",
+    get: function get() {
+      return _SessionItemResult.default.create(this.getState().getIn(['sessionItemResults', this.id]));
+    }
+  }, {
+    key: "type",
+    get: function get() {
+      return this.stimulus !== null ? 'Stimulus' : 'Item';
+    }
+  }, {
+    key: "isStimulus",
+    get: function get() {
+      return this.type === 'Stimulus';
+    }
+  }, {
+    key: "stimulusRecord",
+    get: function get() {
+      return _Stimulus.default.create(this.stimulus);
+    }
+  }, {
+    key: "itemRecord",
+    get: function get() {
+      return _Item.default.create(this.item);
+    }
+  }, {
+    key: "hasNestedRecords",
+    get: function get() {
+      return this.isStimulus;
+    }
+  }, {
+    key: "positionSlots",
+    get: function get() {
+      // decrement to account for stimulus not being its own sessionItem
+      // and the generateDisplayPositions assume each item with nested
+      // values does not count itself, but it can't be negative
+      var slots = this.displayPositionSlots - 1;
+      return slots >= 0 ? slots : 0;
+    }
+  }, {
+    key: "displayPositionSlots",
+    get: function get() {
+      if (this.isStimulus) {
+        return this.getNestedEntries().size;
+      }
+
+      return 1;
+    }
+  }]);
+  return SessionItem;
+}((0, _reduxRecord.default)({
+  id: null,
+  item: {},
+  pointsPossible: null,
+  position: null,
+  quizEntryId: null,
+  quizSessionId: null,
+  scoringData: {},
+  calculatorType: 'none',
+  stimulus: null,
+  stimulusKey: null
+}));
+
+exports.SessionItem = SessionItem;
+var _default = SessionItem;
+exports.default = _default;

package/lib/common/records/SessionItemResult.js

@@ -0,0 +1,91 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.SessionItemResult = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
+
+var _immutable = require("immutable");
+
+var _reduxRecord = _interopRequireDefault(require("./reduxRecord.js"));
+
+var _sessionItems = require("../selectors/sessionItems.js");
+
+var SessionItemResult = /*#__PURE__*/function (_ReduxRecord) {
+  (0, _inherits2.default)(SessionItemResult, _ReduxRecord);
+
+  var _super = (0, _createSuper2.default)(SessionItemResult);
+
+  function SessionItemResult() {
+    (0, _classCallCheck2.default)(this, SessionItemResult);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2.default)(SessionItemResult, [{
+    key: "getItem",
+    value: function getItem() {
+      return (0, _sessionItems.getSessionItemById)(this.getState(), this.id).getItem();
+    }
+  }, {
+    key: "defaultResult",
+    value: function defaultResult(sessionItem) {
+      var defaultResultData = {
+        attempt: 1,
+        itemId: sessionItem.getItem().id,
+        position: sessionItem.position,
+        id: sessionItem.id
+      };
+      return new SessionItemResult(defaultResultData, this.getState());
+    }
+  }, {
+    key: "getWorkingInstance",
+    value: function getWorkingInstance() {
+      var modificationData = this.merge(this.getState().getIn(['modifications', 'sessionItemResults', this.id], (0, _immutable.Map)()));
+      return new SessionItemResult(modificationData, this.getState());
+    }
+  }, {
+    key: "hasModifications",
+    value: function hasModifications() {
+      return !(0, _immutable.is)(this.getWorkingInstance(), this);
+    }
+  }, {
+    key: "isLoaded",
+    value: function isLoaded() {
+      return this.itemId !== null;
+    }
+  }, {
+    key: "isGraded",
+    value: function isGraded() {
+      return !!this.gradedAt;
+    }
+  }]);
+  return SessionItemResult;
+}((0, _reduxRecord.default)({
+  answerFeedback: null,
+  attempt: null,
+  feedback: (0, _immutable.Map)(),
+  gradedAt: null,
+  graderId: null,
+  gradingMethod: null,
+  id: null,
+  itemId: null,
+  regradeInfo: null,
+  pointsPossible: null,
+  position: null,
+  score: null,
+  scoredData: (0, _immutable.Map)()
+}));
+
+exports.SessionItemResult = SessionItemResult;
+var _default = SessionItemResult;
+exports.default = _default;