@instructure/quiz-core 17.19.2-rc.4 → 17.19.3-rc.1

package/lib/taking/api/taking.js

@@ -0,0 +1,371 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.confirmSessionStartPage = confirmSessionStartPage;
+exports.newQuizTakingSession = newQuizTakingSession;
+exports.onQuizSessionReadyForTaking = onQuizSessionReadyForTaking;
+exports.showSubmitConfirmModal = showSubmitConfirmModal;
+exports.closeSubmitConfirmModal = closeSubmitConfirmModal;
+exports.submitQuiz = submitQuiz;
+exports.postQuizSession = postQuizSession;
+exports.getTimeRemaining = getTimeRemaining;
+exports.recordQuizTime = recordQuizTime;
+exports.messageForSubmitModal = exports.nextQuestion = exports.submitStudentAccessCode = exports.makeSessionItemCall = exports.getResumeData = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _partial = _interopRequireDefault(require("lodash/partial"));
+
+var _immutable = require("immutable");
+
+var _humps = require("humps");
+
+var _formatMessage = _interopRequireDefault(require("@instructure/quiz-i18n/es/format-message"));
+
+var _noop = _interopRequireDefault(require("../../common/util/noop.js"));
+
+var _alerts = require("../../common/actions/alerts.js");
+
+var _Item = _interopRequireDefault(require("../../common/records/Item.js"));
+
+var _featureCheck = require("../../common/util/featureCheck.js");
+
+var _QuizEventsLogger = require("../../common/kinesis/QuizEventsLogger.js");
+
+var _quizCommon = require("@instructure/quiz-common");
+
+var uiActions = _interopRequireWildcard(require("../../common/actions/ui.js"));
+
+var _quizSessions = require("../../common/api/quizSessions.js");
+
+var _quizSessions2 = require("../../common/actions/quizSessions.js");
+
+var _callHandlers = require("../../common/api/callHandlers.js");
+
+var modalActions = _interopRequireWildcard(require("../../common/actions/modal.js"));
+
+var _taking = require("../../common/actions/taking.js");
+
+// =============================================
+// =============================================
+//  this file is in charge of coordinating the
+//  dispatching of actions necessary to interact
+//  with quizzes via the api for taking purposes
+// =============================================
+// =============================================
+var getQuizSessionConfig = function getQuizSessionConfig(quizSession) {
+  // these should be handled by existing functions
+  var oneQuestionAtATime = quizSession.isOneQuestionAtATime();
+  var allowBacktracking = quizSession.allowBacktracking;
+  var useSessionItemIndex = !oneQuestionAtATime || allowBacktracking;
+  return {
+    oneQuestionAtATime: oneQuestionAtATime,
+    allowBacktracking: allowBacktracking,
+    useSessionItemIndex: useSessionItemIndex
+  };
+};
+
+var getResumeData = function getResumeData(quizSessionId) {
+  return function (dispatch) {
+    var responseCb = function responseCb(resumeData) {
+      return dispatch((0, _callHandlers.handleResumeDataResponse)(resumeData, quizSessionId));
+    };
+
+    return (0, _quizSessions.fetchResumeData)(quizSessionId, responseCb);
+  };
+};
+
+exports.getResumeData = getResumeData;
+
+var makeSessionItemCall = function makeSessionItemCall(quizSession) {
+  var index = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : _quizSessions2.getSessionItems;
+  var next = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : nextQuestion;
+  return function (dispatch) {
+    var action = getQuizSessionConfig(quizSession).useSessionItemIndex ? index(quizSession.id) : next(quizSession.id, false, false, null, null, null);
+    return dispatch(action);
+  };
+};
+
+exports.makeSessionItemCall = makeSessionItemCall;
+
+var submitStudentAccessCode = function submitStudentAccessCode(quizSessionId, accessCode) {
+  return function (dispatch) {
+    var responseCb = function responseCb(sessionData) {
+      dispatch(uiActions.set(_quizCommon.STUDENT_ACCESS_CODE_STATUS, sessionData.accepted_student_access_code));
+
+      if (sessionData.accepted_student_access_code) {
+        dispatch((0, _alerts.screenreaderNotification)((0, _formatMessage.default)('Access code successful. You may now begin this assessment')));
+      } else {
+        dispatch((0, _alerts.screenreaderNotification)((0, _formatMessage.default)('Invalid access code')));
+      }
+
+      return dispatch((0, _callHandlers.handleQuizSessionResponse)(sessionData, quizSessionId));
+    };
+
+    return (0, _quizSessions.submitStudentAccessCode)(quizSessionId, accessCode, responseCb);
+  };
+}; // ====================================
+// OQAAT no backtracking call
+// ====================================
+
+
+exports.submitStudentAccessCode = submitStudentAccessCode;
+
+var noBacktrackingNextQuestion = function noBacktrackingNextQuestion(quizSessionId, itemId, position, userResponse, largeFormatResponse, submit) {
+  return function (dispatch) {
+    var params = {};
+
+    if (itemId) {
+      params.body = JSON.stringify({
+        sessionItemResponse: {
+          itemId: itemId,
+          position: position,
+          userResponse: userResponse,
+          largeFormatResponse: largeFormatResponse
+        }
+      });
+    }
+
+    var responseCb = function responseCb(nextItem) {
+      if (nextItem) {
+        dispatch([(0, _callHandlers.handleSessionItemsResponse)([nextItem], quizSessionId), (0, _taking.setCurrentSessionItemPosition)(nextItem.position)]);
+      } else {
+        submit();
+      }
+    };
+
+    var errorCb = function errorCb(errorCode) {
+      if (errorCode === 400) {
+        return (0, _quizSessions.singleResponseSubmit)(quizSessionId, {}, responseCb);
+      }
+    };
+
+    return (0, _quizSessions.singleResponseSubmit)(quizSessionId, params, responseCb, errorCb);
+  };
+}; // ====================================
+// OQAAT no backtracking call
+// ====================================
+
+
+var nextQuestion = function nextQuestion(quizSessionId, allowBacktracking, currentQuestionIsLast, position, itemId, userResponse, largeFormatResponse) {
+  var submit = arguments.length > 7 && arguments[7] !== void 0 ? arguments[7] : submitQuiz;
+
+  if (allowBacktracking) {
+    return function (dispatch) {
+      var action = currentQuestionIsLast ? submit(quizSessionId) : (0, _taking.backtrackingNextQuestion)();
+      if (action) dispatch(action);
+    };
+  } else {
+    return noBacktrackingNextQuestion(quizSessionId, itemId, position, userResponse, largeFormatResponse, submit);
+  }
+}; // ====================================
+// load up the quiz session for the taking page
+// ====================================
+
+
+exports.nextQuestion = nextQuestion;
+
+function confirmSessionStartPage(quizSessionId) {
+  var cb = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : _noop.default;
+  var authRedirectCb = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : _noop.default;
+  return function (dispatch) {
+    return (0, _quizSessions.fetchQuizSession)(quizSessionId, (0, _partial.default)(_quizSessions2.handleQuizSessionFetch, dispatch)).then(cb).catch(function (e) {
+      if (e.response && e.response.status === 403) {
+        authRedirectCb();
+      }
+    });
+  };
+} // ====================================
+// fetch the data for a new quiz_session
+// ====================================
+
+
+function newQuizTakingSession(quizSessionId) {
+  var cb = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : _noop.default;
+  var authRedirectCb = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : _noop.default;
+  return function (dispatch) {
+    return (0, _quizSessions.takeQuizSession)(quizSessionId, (0, _partial.default)(_quizSessions2.handleQuizSessionFetch, dispatch)).then(cb).catch(function (e) {
+      if (e.response.status === 403) {
+        authRedirectCb();
+      }
+    });
+  };
+}
+
+function onQuizSessionReadyForTaking(quizSession) {
+  return function (dispatch) {
+    dispatch([makeSessionItemCall(quizSession), getResumeData(quizSession.id), (0, _taking.sessionStartOrResumeEvent)(navigator.userAgent), (0, _taking.updateQuizSessionStatusOnPageLoad)(quizSession.status)]);
+  };
+} // ====================================
+// show submit confirmation modal
+// ====================================
+
+
+var messageForSubmitModal = function messageForSubmitModal(positions) {
+  if (!positions || positions.length === 0) {
+    return (0, _formatMessage.default)('Upon submission you will not be able to change your answers. Are you ready to submit?');
+  }
+
+  if (positions.length >= 10) {
+    return (0, _featureCheck.featureOn)('invalid_input_warning') ? (0, _formatMessage.default)('Multiple questions have either not been answered or have invalid answers. Upon submission you will not be able to change your answers. Are you ready to submit?') : (0, _formatMessage.default)('Multiple questions have not been answered. Upon submission you will not be able to change your answers. Are you ready to submit?');
+  }
+
+  var message = (0, _featureCheck.featureOn)('invalid_input_warning') ? (0, _formatMessage.default)('The following questions have either not been answered or have invalid answers:') : (0, _formatMessage.default)('The following questions have not been answered:');
+  return /*#__PURE__*/_react.default.createElement("div", null, /*#__PURE__*/_react.default.createElement("p", null, message), /*#__PURE__*/_react.default.createElement("ul", null, positions.map(function (position) {
+    return /*#__PURE__*/_react.default.createElement("li", {
+      key: position
+    }, (0, _formatMessage.default)('Question { position, number }', {
+      position: position
+    }));
+  })), /*#__PURE__*/_react.default.createElement("p", null, (0, _formatMessage.default)('Upon submission you will not be able to change your answers. Are you ready to submit?')));
+};
+
+exports.messageForSubmitModal = messageForSubmitModal;
+
+var __getResponseForSessionItem = function __getResponseForSessionItem(sessionItem, responses) {
+  var resp = responses.find(function (r) {
+    return r.get('position') === sessionItem.get('position');
+  });
+
+  if ((0, _featureCheck.featureOn)('invalid_input_warning') && resp && resp.get('invalid')) {
+    return null;
+  }
+
+  return resp && resp.get('userResponse').toJS();
+};
+
+var __remainingQuestionPositions = function __remainingQuestionPositions(sessionItems, responses) {
+  return sessionItems.toList().sortBy(function (si) {
+    return si.get('position');
+  }).filterNot(function (si) {
+    var item = new _Item.default(si.get('item'));
+
+    var itemUserResponse = __getResponseForSessionItem(si, responses);
+
+    return item.hasResponse(itemUserResponse);
+  }).map(function (si) {
+    return si.get('position');
+  }).toSet().toJS();
+};
+
+function showSubmitConfirmModal(quizSessionId) {
+  var onSubmitQuizSession = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : _noop.default;
+  return function (dispatch, getState) {
+    var needResponse = getQuestionsNeedingAResponse(getState(), quizSessionId);
+    var title = titleForSubmitModal(needResponse);
+    var message = messageForSubmitModal(needResponse);
+    var modalAction = modalActions.withConfirm(function () {
+      return dispatch(postQuizSession(quizSessionId, onSubmitQuizSession));
+    }, {
+      title: title,
+      text: message,
+      continueText: (0, _formatMessage.default)('Submit'),
+      cancelText: (0, _formatMessage.default)('Cancel')
+    });
+    return dispatch(modalAction);
+  };
+}
+
+function closeSubmitConfirmModal(quizSessionId) {
+  return function (dispatch, getState) {
+    var needResponse = getQuestionsNeedingAResponse(getState(), quizSessionId);
+    var title = titleForSubmitModal(needResponse);
+    return dispatch(modalActions.closeModal(title));
+  };
+}
+
+function titleForSubmitModal(needResponse) {
+  return needResponse.length > 0 ? (0, _formatMessage.default)('Unanswered Questions!') : (0, _formatMessage.default)('Confirm Submission');
+} // ==============================================
+// check for unanswered questions or override
+// ==============================================
+
+
+function submitQuiz(quizSessionId) {
+  var onSubmitQuizSession = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : _noop.default;
+  var overrideConfirmation = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+  return function (dispatch) {
+    if (overrideConfirmation) {
+      return dispatch(postQuizSession(quizSessionId, onSubmitQuizSession));
+    } else {
+      return dispatch(showSubmitConfirmModal(quizSessionId, onSubmitQuizSession));
+    }
+  };
+}
+
+function getQuestionsNeedingAResponse(state, quizSessionId) {
+  var responses = state.getIn(['taking', 'responses'], (0, _immutable.Map)());
+  var sessionItems = state.get('sessionItems', (0, _immutable.Map)()).filter(function (record) {
+    return record.get('quizSessionId') === quizSessionId;
+  });
+  return __remainingQuestionPositions(sessionItems, responses);
+} // ====================================
+// submit the data for the quiz
+// ====================================
+
+
+function postQuizSession(quizSessionId) {
+  var onSubmitQuizSession = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : _noop.default;
+  // send kinesis credentials request before submit quiz when it is still
+  //   in quiz.taking scope, we don't mind when responses are coming back (
+  //   before/after the scope is switched)
+  // after submit quiz response is received, kinesis refresh is forbidden for
+  //   quiz.results scope
+  (0, _QuizEventsLogger.fetchLogger)(quizSessionId);
+  return function (dispatch, getState) {
+    var submitFlag = getState().getIn(['taking', 'submitFlag']);
+
+    if (!submitFlag) {
+      dispatch((0, _taking.updateQuizSubmitFlag)(true));
+      var takingResponses = getState().getIn(['taking', 'responses'], (0, _immutable.Map)()).valueSeq().toJS();
+      var params = {
+        body: JSON.stringify({
+          session_item_responses: takingResponses
+        })
+      };
+      var submitQuizSessionEventAction = (0, _taking.submitQuizSessionEvent)();
+
+      var responseCb = function responseCb() {
+        dispatch((0, _alerts.screenreaderNotification)((0, _formatMessage.default)('Quiz submitted')));
+        onSubmitQuizSession();
+        dispatch(submitQuizSessionEventAction);
+      };
+
+      var errorCb = function errorCb(errorCode) {
+        setTimeout(function () {
+          dispatch((0, _taking.updateQuizSubmitFlag)(false));
+        }, 10000);
+      };
+
+      return (0, _quizSessions.submitQuizSession)(quizSessionId, params, responseCb, errorCb);
+    }
+  };
+} // ====================================
+//  getting the remaining time
+// ====================================
+
+
+function getTimeRemaining(quizSessionId, cb) {
+  return function (dispatch) {
+    return (0, _quizSessions.fetchTime)(quizSessionId, function (result) {
+      return cb((0, _humps.camelizeKeys)(result));
+    });
+  };
+} // ====================================
+//  tracking time taken
+// ====================================
+
+
+function recordQuizTime(quizSessionId, cb) {
+  return function (dispatch) {
+    return (0, _quizSessions.recordTime)(quizSessionId, function (result) {
+      return cb((0, _humps.camelizeKeys)(result));
+    });
+  };
+}

package/lib/taking/learnosity/index.js

@@ -0,0 +1,195 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.appendFeature = appendFeature;
+exports.destroyFeature = destroyFeature;
+exports.toggleFeature = toggleFeature;
+exports.reset = reset;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _Fetcher = _interopRequireDefault(require("../../common/util/Fetcher.js"));
+
+var _loader = _interopRequireDefault(require("./loader.js"));
+
+var questionsApp;
+var authPromise;
+
+function appendFeature(_x, _x2, _x3) {
+  return _appendFeature.apply(this, arguments);
+}
+
+function _appendFeature() {
+  _appendFeature = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(quizSessionId, feature, timeout) {
+    var _len,
+        args,
+        _key,
+        _args = arguments;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            if (questionsApp) {
+              _context.next = 5;
+              break;
+            }
+
+            for (_len = _args.length, args = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+              args[_key - 3] = _args[_key];
+            }
+
+            _context.next = 4;
+            return authenticate.apply(void 0, [quizSessionId].concat(args));
+
+          case 4:
+            questionsApp = _context.sent;
+
+          case 5:
+            if (!featureContainer(feature.feature_id)) {
+              _context.next = 11;
+              break;
+            }
+
+            questionsApp.append({
+              features: [feature]
+            });
+            _context.next = 9;
+            return waitForLearnosityReadyCallback(timeout, feature.feature_id);
+
+          case 9:
+            _context.next = 12;
+            break;
+
+          case 11:
+            throw new Error('Learnosity feature container element not found');
+
+          case 12:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _appendFeature.apply(this, arguments);
+}
+
+function destroyFeature(featureId) {
+  if (!questionsApp) return;
+  var feature = questionsApp.feature(featureId);
+
+  if (feature) {
+    feature.destroy();
+  }
+}
+
+function toggleFeature(featureId, onOff) {
+  if (!questionsApp) return;
+  var feature = questionsApp.feature(featureId);
+
+  if (feature) {
+    feature.toggle(onOff);
+  }
+}
+
+function featureContainer(featureId) {
+  return document.querySelector(".learnosity-feature.feature-".concat(featureId));
+}
+
+function authenticate(quizSessionId) {
+  var loader = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : _loader.default;
+  var fetcher = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null;
+  authPromise = authPromise || new Promise(function (resolve, reject) {
+    var f = fetcher || new _Fetcher.default();
+    Promise.all([loader(), f.post("/api/quiz_sessions/".concat(quizSessionId, "/learnosity_authentication?domain=").concat(window.location.hostname))]).then(function (_ref) {
+      var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+          app = _ref2[0],
+          response = _ref2[1];
+
+      var questionsApp = app.init(response, {
+        errorListener: function errorListener(e) {
+          authPromise = null;
+          reject(e);
+        },
+        readyListener: function readyListener() {
+          authPromise = null;
+          resolve(questionsApp);
+          learnosityReady();
+        }
+      });
+    }).catch(function (e) {
+      authPromise = null;
+      reject(e);
+    });
+  });
+  return authPromise;
+} // Learnosity calls readyListener when it has finished loading, and again when
+// a feature has been appended to the DOM. The following is gross, but it
+// allows us to await until a feature is ready.
+
+
+var pendingFeaturesPromise, pendingFeatures, pendingCount;
+
+function resetPending() {
+  pendingFeaturesPromise = null;
+  pendingFeatures = {};
+  pendingCount = 0;
+}
+
+resetPending();
+
+function learnosityReady() {
+  // We can't know which feature is ready, so only resolve once there are
+  // no more pending features
+  if (pendingCount > 0) {
+    pendingCount -= 1;
+
+    if (pendingCount === 0) {
+      pendingFeaturesPromise.resolve();
+      resetPending();
+    }
+  }
+}
+
+function waitForLearnosityReadyCallback() {
+  var timeout = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 5000;
+  var featureId = arguments.length > 1 ? arguments[1] : void 0;
+
+  if (!pendingFeatures[featureId]) {
+    pendingCount += 1;
+    pendingFeatures[featureId] = true;
+    var res;
+
+    if (!pendingFeaturesPromise) {
+      pendingFeaturesPromise = new Promise(function (resolve, reject) {
+        var timer = setTimeout(function () {
+          reject(new Error('Timed out waiting for learnosity ready callback'));
+          resetPending();
+        }, timeout);
+
+        res = function res() {
+          clearTimeout(timer);
+          resolve();
+        };
+      });
+      pendingFeaturesPromise.resolve = res;
+    }
+  }
+
+  return pendingFeaturesPromise;
+} // Only used to reset singleton state for tests
+
+
+function reset() {
+  questionsApp = null;
+  authPromise = null;
+  resetPending();
+}

package/lib/taking/learnosity/loader.js

@@ -0,0 +1,87 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loadLearnositySdk;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+/* global LearnosityApp */
+var learnosityURL = 'https://questions.learnosity.com/?v2';
+var promise;
+
+function loadLearnositySdk() {
+  return _loadLearnositySdk.apply(this, arguments);
+}
+
+function _loadLearnositySdk() {
+  _loadLearnositySdk = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            if (!promise) {
+              promise = fetchSdk();
+            }
+
+            return _context.abrupt("return", promise);
+
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _loadLearnositySdk.apply(this, arguments);
+}
+
+function fetchSdk() {
+  return _fetchSdk.apply(this, arguments);
+}
+
+function _fetchSdk() {
+  _fetchSdk = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+    var response, learnositySdk, addScript;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return window.fetch(learnosityURL);
+
+          case 2:
+            response = _context2.sent;
+
+            if (response.ok) {
+              _context2.next = 5;
+              break;
+            }
+
+            throw new Error('Failed to load the Learnosity SDK');
+
+          case 5:
+            _context2.next = 7;
+            return response.text();
+
+          case 7:
+            learnositySdk = _context2.sent;
+            addScript = document.createElement('script');
+            addScript.textContent = learnositySdk;
+            document.body.appendChild(addScript);
+            return _context2.abrupt("return", LearnosityApp);
+
+          case 12:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _fetchSdk.apply(this, arguments);
+}