@instructure/quiz-core 17.19.2 → 17.20.0

package/lib/building/api/quizEntries.js

@@ -0,0 +1,380 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getQuizEntry = getQuizEntry;
+exports.getQuizEntries = getQuizEntries;
+exports.createQuizEntry = createQuizEntry;
+exports.updateQuizEntry = updateQuizEntry;
+exports.cloneQuizEntry = cloneQuizEntry;
+exports.moveQuizEntry = moveQuizEntry;
+exports.moveImmutableQuizEntry = moveImmutableQuizEntry;
+exports.removeQuizEntry = removeQuizEntry;
+exports.removeStimulusQuizEntry = removeStimulusQuizEntry;
+exports.createItemAndQuizEntry = exports.createStimulusAndQuizEntry = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _pick = _interopRequireDefault(require("lodash/pick"));
+
+var _pickBy = _interopRequireDefault(require("lodash/pickBy"));
+
+var _humps = require("humps");
+
+var _Fetcher = _interopRequireDefault(require("../../common/util/Fetcher.js"));
+
+var _ExhaustivePaginatedFetcher = _interopRequireDefault(require("../../common/util/ExhaustivePaginatedFetcher.js"));
+
+var _scrolling = require("../../common/actions/scrolling.js");
+
+var _ThunkQueue = _interopRequireDefault(require("../../common/util/ThunkQueue.js"));
+
+var _noop = _interopRequireDefault(require("../../common/util/noop.js"));
+
+var _quizCommon = require("@instructure/quiz-common");
+
+var _items = require("./items.js");
+
+var _stimuli = require("./stimuli.js");
+
+var _alerts = require("../../common/actions/alerts.js");
+
+var _quizEntries = require("../../common/actions/quizEntries.js");
+
+var _ui = require("../../common/actions/ui.js");
+
+var _quizzes = require("../../common/actions/quizzes.js");
+
+var _callHandlers = require("../../common/api/callHandlers.js");
+
+var _quizzes2 = require("../../common/api/quizzes.js");
+
+var _QuizEntry = _interopRequireDefault(require("../../common/records/QuizEntry.js"));
+
+var _formatMessage = _interopRequireDefault(require("@instructure/quiz-i18n/es/format-message"));
+
+// Actions that involve an API call should happen in order, to prevent race
+// conditions (a user moving a question into a stimulus then immediately
+// deleting the stimulus, for example). We use this queue to make sure requests
+// wait for previous requests to finish, without preventing UI updates.
+var queue = new _ThunkQueue.default(function (error, dispatch, getState) {
+  // If an action fails, re-fetch all quiz entries from the backend
+  var activeQuizId = getState().getIn(['quizzes', 'activeQuizId']);
+  dispatch(getQuizEntries(activeQuizId));
+  throw error;
+}); // =====================
+// =====================
+//       GET INDEX
+// =====================
+// =====================
+
+var handleQuizEntriesGet = function handleQuizEntriesGet(dispatch, quizId, quizEntries) {
+  dispatch([(0, _callHandlers.handleQuizEntriesResponse)(quizEntries, quizId), (0, _quizzes.associateQuizEntries)(quizId, quizEntries)]);
+  return quizEntries;
+};
+
+function getQuizEntry(quizId, quizEntryId) {
+  var url = "/api/quizzes/".concat(quizId, "/quiz_entries/").concat(quizEntryId);
+  return function (dispatch, getState) {
+    var fetcher = new _Fetcher.default();
+    return fetcher.get(url).then(function (data) {
+      return handleQuizEntriesGet(dispatch, quizId, [data]);
+    });
+  };
+}
+
+function getQuizEntries(quizId) {
+  var cb = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : _noop.default;
+  var url = "/api/quizzes/".concat(quizId, "/quiz_entries");
+  return function (dispatch, getState) {
+    var fetcher = new _ExhaustivePaginatedFetcher.default();
+    return fetcher.get(url).then(function (data) {
+      return handleQuizEntriesGet(dispatch, quizId, data);
+    }).then(cb);
+  };
+} // =====================
+// =====================
+//       CREATE
+// =====================
+// =====================
+
+
+function createEntryAndQuizEntry(quizId, entry, quizEntry, entryCreationCb, quizEntryCreationCb) {
+  return function (dispatch, getState) {
+    var entryProperties = quizEntry.getProperties();
+    return dispatch(entryCreationCb(entry, quizId, 'quiz')).then(function (entryData) {
+      return dispatch(quizEntryCreationCb(quizId, entryData.id, quizEntry.get('entryType'), entryProperties));
+    });
+  };
+}
+
+var createStimulusAndQuizEntry = queue.wrapActionCreator(function (quizId, stimulus, quizEntry) {
+  var stimulusCreationCb = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : _stimuli.createStimulus;
+  var quizEntryCreationCb = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : createQuizEntry;
+  return createEntryAndQuizEntry(quizId, stimulus, quizEntry, stimulusCreationCb, quizEntryCreationCb);
+});
+exports.createStimulusAndQuizEntry = createStimulusAndQuizEntry;
+var createItemAndQuizEntry = queue.wrapActionCreator(function (quizId, item, quizEntry) {
+  var itemCreationCb = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : _items.createItem;
+  var quizEntryCreationCb = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : createQuizEntry;
+  return createEntryAndQuizEntry(quizId, item, quizEntry, itemCreationCb, quizEntryCreationCb);
+});
+exports.createItemAndQuizEntry = createItemAndQuizEntry;
+
+function createQuizEntry(quizId, entryId, entryType, entryProperties) {
+  var requireFocus = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : true;
+  var url = "/api/quizzes/".concat(quizId, "/quiz_entries");
+  var quizEntryParams = (0, _objectSpread2.default)({
+    quizId: quizId,
+    entryType: entryType,
+    entryId: entryId
+  }, entryProperties);
+  var body = JSON.stringify({
+    quiz_entry: quizEntryParams
+  });
+  return function (dispatch, getState) {
+    var fetcher = new _Fetcher.default({
+      callType: _quizCommon.CREATE_QUIZ_ENTRY_CALL,
+      onError: function onError() {
+        return (0, _alerts.addError)((0, _formatMessage.default)('Failed to create quiz entry.'));
+      }
+    }); // TODO: this re-fetches all quiz entries after the new quiz entry is
+    // created. This causes the new question to disappear and reappear after a
+    // noticeable delay. Should we add the quiz entry optimistically, for
+    // better UX?
+
+    return fetcher.post(url, {
+      body: body
+    }).then(function (response) {
+      var scrollCallback = function scrollCallback() {
+        return dispatch((0, _scrolling.scrollToItem)(response.id, requireFocus));
+      };
+
+      return dispatch(getQuizEntries(quizId, scrollCallback));
+    });
+  };
+} // =====================
+// =====================
+//    UPDATE, CLONE & MOVE
+// =====================
+// =====================
+// UPDATE HELPER
+
+
+function updateBody(updatedProperties) {
+  var properties = updatedProperties.properties;
+
+  if (properties && properties.selection === 'all') {
+    properties.sampleNum = null;
+  }
+
+  var validProperties = Object.keys(updatedProperties).map(_humps.decamelize).concat(['properties']);
+  var entryProperties = (0, _pick.default)({
+    points_possible: parseFloat(updatedProperties.pointsPossible),
+    position: updatedProperties.position,
+    stimulus_quiz_entry_id: updatedProperties.stimulusQuizEntryId,
+    entry_id: updatedProperties.entryId,
+    entry_type: updatedProperties.entryType,
+    properties: properties
+  }, validProperties);
+
+  var isDefined = function isDefined(val) {
+    return val !== null && val !== void 0;
+  };
+
+  var entryPropsToUpdate = (0, _pickBy.default)(entryProperties, isDefined);
+  return JSON.stringify({
+    quiz_entry: entryPropsToUpdate
+  });
+} // Update the given quiz entry. If handleResponse is true, the redux store will
+// be updated with response data when it comes back. You may want to set
+// handleResponse to false for some optimistic update flows.
+
+
+function updateQuizEntry(quizId, quizEntryId, updatedProperties) {
+  var _ref = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {},
+      _ref$handleResponse = _ref.handleResponse,
+      handleResponse = _ref$handleResponse === void 0 ? true : _ref$handleResponse;
+
+  var url = "/api/quizzes/".concat(quizId, "/quiz_entries/").concat(quizEntryId);
+  var fetcher = new _Fetcher.default({
+    callType: _quizCommon.UPDATE_QUIZ_ENTRY_CALL,
+    onError: function onError() {
+      return (0, _alerts.addError)((0, _formatMessage.default)('Failed to update quiz entry.'));
+    }
+  });
+  var body = updateBody(updatedProperties);
+  return /*#__PURE__*/function () {
+    var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(dispatch, getState) {
+      var response;
+      return _regenerator.default.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return fetcher.patch(url, {
+                body: body
+              });
+
+            case 2:
+              response = _context.sent;
+
+              if (handleResponse) {
+                dispatch((0, _callHandlers.handleQuizEntryResponse)(response));
+              }
+
+            case 4:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function (_x, _x2) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+}
+
+function cloneQuizEntry(quizId, quizEntryId, updatedProperties) {
+  var url = "/api/quizzes/".concat(quizId, "/quiz_entries/").concat(quizEntryId, "/clone");
+  var fetcher = new _Fetcher.default({
+    callType: _quizCommon.CLONE_QUIZ_ENTRY_CALL,
+    onError: function onError() {
+      return (0, _alerts.addError)((0, _formatMessage.default)('Failed to clone quiz entry.'));
+    }
+  });
+  var body = updateBody(updatedProperties);
+  return function (dispatch, getState) {
+    return fetcher.post(url, {
+      body: body
+    }).then(function (qeData) {
+      dispatch((0, _callHandlers.handleQuizEntryResponse)(qeData));
+      return qeData;
+    }).then(function () {
+      return dispatch((0, _quizzes2.getExistingQuizAndItems)(quizId));
+    });
+  };
+}
+
+function moveQuizEntry(quizId, position, stimulusQuizEntryId, quizEntryId, moveTempItem) {
+  var updateAction = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : updateQuizEntry;
+  return function (dispatch, getState) {
+    // Optimistically move the quiz entry in the redux store without waiting
+    // for a response.
+    return dispatch([(0, _quizEntries.moveQuizEntry)(quizEntryId, position, stimulusQuizEntryId), (0, _ui.set)(_quizCommon.MOVED_QUIZ_ENTRY, quizEntryId)]).then(function () {
+      moveTempItem && moveTempItem(); // this functionality was temporarily disabled in 9c03aa9
+
+      var queuedUpdate = queue.wrapThunk(updateAction(quizId, quizEntryId, {
+        position: position,
+        stimulusQuizEntryId: stimulusQuizEntryId
+      }, {
+        handleResponse: false
+      }));
+      return dispatch(queuedUpdate);
+    });
+  };
+}
+
+function moveImmutableQuizEntry(quizId, position, stimulusQuizEntryId, quizEntryId) {
+  var createItemAction = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : _items.createItem;
+  var updateAction = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : updateQuizEntry;
+  return function (dispatch, getState) {
+    return dispatch(moveQuizEntry(quizId, position, stimulusQuizEntryId, quizEntryId, void 0, // We pass a noop action creator here to only move the quiz entry in our
+    // local state, not on the backend. We need to wait to move the entry on
+    // the backend until after the new item has been created, otherwise the
+    // backend will complain about trying to update an immutable item.
+    function () {
+      return {
+        type: _quizCommon.DO_NOTHING
+      };
+    })).then(function () {
+      return dispatch(createItemAndMoveQuizEntry(quizId, position, stimulusQuizEntryId, quizEntryId, createItemAction, updateAction));
+    });
+  };
+}
+
+var createItemAndMoveQuizEntry = queue.wrapActionCreator(function (quizId, position, stimulusQuizEntryId, quizEntryId) {
+  var createItemAction = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : _items.createItem;
+  var updateAction = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : updateQuizEntry;
+  return function (dispatch, getState) {
+    var quizEntry = _QuizEntry.default.create(getState().getIn(['quizEntries', quizEntryId]));
+
+    var workingItem = quizEntry.getEntry().getWorkingInstance();
+    return dispatch(createItemAction(workingItem, quizId, 'quiz', workingItem.id)).then(function (_ref3) {
+      var id = _ref3.id;
+      return dispatch(updateAction(quizId, quizEntryId, {
+        entryId: id,
+        position: position,
+        stimulusQuizEntryId: stimulusQuizEntryId
+      }, {
+        handleResponse: false
+      }));
+    });
+  };
+}); // =====================
+// =====================
+//       DESTROY
+// =====================
+// =====================
+
+function quizEntryDeleted(dispatch, quizEntry) {
+  setTimeout(function () {
+    dispatch((0, _ui.set)(_quizCommon.DELETED_QUIZ_ENTRY, {
+      position: quizEntry.position,
+      inStimulus: quizEntry.isInStimulus
+    }));
+  }, 100);
+}
+
+var deleteQuizEntry = queue.wrapActionCreator(function (url, params) {
+  return function (dispatch, getState) {
+    var fetcher = new _Fetcher.default({
+      callType: _quizCommon.DELETE_QUIZ_ENTRY_CALL,
+      onError: function onError() {
+        return (0, _alerts.addError)((0, _formatMessage.default)('Failed to remove quiz entry.'));
+      }
+    });
+    return fetcher.delete(url, params);
+  };
+});
+
+function removeQuizEntry(quizId, quizEntry) {
+  var url = "/api/quizzes/".concat(quizId, "/quiz_entries/").concat(quizEntry.id);
+  return function (dispatch, getState) {
+    return dispatch([(0, _quizEntries.deleteQuizEntry)(quizEntry.id), (0, _quizzes.disassociateQuizEntry)(quizId, quizEntry.id)]).then(function () {
+      quizEntryDeleted(dispatch, quizEntry);
+      return dispatch(deleteQuizEntry(url));
+    });
+  };
+}
+
+function removeStimulusQuizEntry(quizId, stimulusEntry, childEntries) {
+  var url = "/api/quizzes/".concat(quizId, "/quiz_entries/").concat(stimulusEntry.id, "/stimuli");
+  var childEntryIds = childEntries.map(function (e) {
+    return e.id;
+  });
+  return function (dispatch, getState) {
+    var body = JSON.stringify({
+      child_ids: childEntryIds
+    });
+    return dispatch([(0, _quizEntries.deleteStimulusEntry)(stimulusEntry.id, childEntryIds), (0, _quizzes.disassociateQuizEntry)(quizId, stimulusEntry.id)].concat((0, _toConsumableArray2.default)(childEntryIds.map(function (id) {
+      return (0, _quizzes.disassociateQuizEntry)(quizId, id);
+    })))).then(function () {
+      quizEntryDeleted(dispatch, stimulusEntry);
+      return dispatch(deleteQuizEntry(url, {
+        body: body
+      }));
+    });
+  };
+}

package/lib/building/api/quizzes.js

@@ -0,0 +1,285 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.quizBuildingSession = quizBuildingSession;
+exports.saveQuizChange = saveQuizChange;
+exports.startNewQuiz = startNewQuiz;
+exports.getExistingQuizAndItemsForBuilding = getExistingQuizAndItemsForBuilding;
+exports.interactionFileUpload = interactionFileUpload;
+exports.setQuizShuffleQuestions = setQuizShuffleQuestions;
+exports.setQuizShuffleAnswers = setQuizShuffleAnswers;
+exports.setRequireStudentAccessCode = setRequireStudentAccessCode;
+exports.setStudentAccessCodeUi = setStudentAccessCodeUi;
+exports.setStudentAccessCodeApi = setStudentAccessCodeApi;
+exports.setOneAtATimeType = setOneAtATimeType;
+exports.setBacktracking = setBacktracking;
+exports.setQuizHasTimeLimit = setQuizHasTimeLimit;
+exports.setSessionTimeLimitInSecondsUi = setSessionTimeLimitInSecondsUi;
+exports.setSessionTimeLimitInSecondsApi = setSessionTimeLimitInSecondsApi;
+exports.setFilterIpAddress = setFilterIpAddress;
+exports.setIpFiltersUi = setIpFiltersUi;
+exports.setIpFiltersApi = setIpFiltersApi;
+exports.setCalculatorType = setCalculatorType;
+
+var _immutable = require("immutable");
+
+var _quizCommon = require("@instructure/quiz-common");
+
+var _Fetcher = _interopRequireDefault(require("../../common/util/Fetcher.js"));
+
+var _qtiImports = require("./qtiImports.js");
+
+var _modifications = require("../../common/actions/modifications.js");
+
+var _callHandlers = require("../../common/api/callHandlers.js");
+
+var _fileUpload = require("../../common/api/fileUpload.js");
+
+var _interactionTypes = require("../../common/api/interactionTypes.js");
+
+var _quizzes = require("../../common/api/quizzes.js");
+
+var config = require('../../config');
+
+var quizApiEndpoint = '/api/quizzes'; // ==== CALLBACKS ====
+
+var handleQuizFetch = function handleQuizFetch(dispatch, quiz) {
+  (0, _quizzes.quizFetchHandler)(dispatch, quiz); // if feature is on, fetch qti import data
+
+  dispatch((0, _qtiImports.getQTIInfo)(quiz.id));
+}; // ==================
+// ==========================================
+// called by the router when a quiz is needed
+// knows how to create a new quiz, fetch
+// an existing quiz, or set activeId depending
+// on the current state & params
+// ==========================================
+
+
+function quizBuildingSession(routerParams) {
+  return function (dispatch, getState) {
+    var contextId = routerParams.contextId;
+    var quizId = routerParams.activeQuizId;
+    var createNew = routerParams.createNew;
+    var needsQuiz = quizId === _quizCommon.NEW_QUIZ_ID || !quizId; // create a new quiz if none exists
+
+    if (createNew && needsQuiz) {
+      return dispatch(startNewQuiz(contextId));
+    } // do nothing if already on quiz and questions are loaded
+
+
+    var currentQuizId = getState().getIn(['quizzes', 'activeQuizId']);
+    var quizEntries = getState().get('quizEntries', (0, _immutable.Map)());
+
+    if (currentQuizId === quizId && quizEntries.size > 0) {
+      return {
+        type: _quizCommon.DO_NOTHING
+      };
+    }
+
+    dispatch(getExistingQuizAndItemsForBuilding(quizId));
+  };
+} // ====================================
+// save quiz changed, and on success
+// add these changes to the quiz store
+// ====================================
+
+
+function saveQuizChange(workingQuiz, quiz) {
+  if (workingQuiz.equals(quiz)) {
+    // cannot just return null since
+    // dispatch expects an action
+    return {
+      type: _quizCommon.DO_NOTHING
+    };
+  }
+
+  var url = "".concat(quizApiEndpoint, "/").concat(workingQuiz.get('id'));
+  var quizData = JSON.stringify(workingQuiz.validData().toJS());
+  return function (dispatch, getState) {
+    var params = {
+      body: quizData
+    };
+    var fetcher = new _Fetcher.default({
+      callType: _quizCommon.QUIZ_SAVE_CALL
+    });
+    return fetcher.patch(url, params).then(function (quizData) {
+      dispatch((0, _callHandlers.handleQuizResponse)(quizData));
+    });
+  };
+} // =================================
+// create a new quiz, add its data,
+// and add it as the active quiz
+// =================================
+
+
+function startNewQuiz(contextId) {
+  return function (dispatch, getState) {
+    var newQuizData = JSON.stringify({
+      title: 'Add Title...',
+      context_id: contextId || config.defaultContextId
+    });
+    var params = {
+      body: newQuizData
+    };
+    var fetcher = new _Fetcher.default();
+    return fetcher.post(quizApiEndpoint, params).then(function (quizData) {
+      handleQuizFetch(dispatch, quizData);
+    }).then(function () {
+      dispatch((0, _interactionTypes.interactionTypeFetch)());
+    });
+  };
+} // ====================================
+// fetch the data for an existing quiz
+// and add it as the active quiz
+// ====================================
+
+
+function getExistingQuizAndItemsForBuilding(quizId) {
+  var fetchTags = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+  // TODO: handleQuizFetch is not handled in getExistingQuizAndItems,
+  //       so determine impact of getQTIInfo not being dispatched
+  return (0, _quizzes.getExistingQuizAndItems)(quizId, fetchTags, handleQuizFetch);
+} // =========================================
+//  media upload endpoint funcs
+// =========================================
+
+
+function getPathToGetUrl(parentType, parentId) {
+  switch (parentType) {
+    case _quizCommon.PARENT_TYPE_BANK:
+      return "/api/banks/".concat(parentId, "/items/media_upload_url");
+
+    case _quizCommon.PARENT_TYPE_QUIZ:
+      return "/api/quizzes/".concat(parentId, "/items/media_upload_url");
+
+    case _quizCommon.PARENT_TYPE_QUIZ_SESSION:
+      return "/api/quiz_sessions/".concat(parentId, "/media_upload_url");
+  }
+}
+
+function interactionFileUpload(parentType, parentId, file, onSuccess, onError, uploadPath) {
+  var withUrlCallback = arguments.length > 6 && arguments[6] !== void 0 ? arguments[6] : _fileUpload.sendFileToS3;
+  return function (dispatch, getState) {
+    var pathToGetUrl = uploadPath || getPathToGetUrl(parentType, parentId);
+    return (0, _fileUpload.getUploadUrl)(pathToGetUrl).then(withUrlCallback(file, onSuccess, onError));
+  };
+} // ====================================
+// update the data for an existing quiz
+// ====================================
+
+
+function setQuizProperty(quizId, properties, action) {
+  var url = "/api/quizzes/".concat(quizId);
+  var body = JSON.stringify({
+    id: quizId,
+    quiz: properties
+  });
+  return function (dispatch, getState) {
+    var params = {
+      body: body
+    };
+    var fetcher = new _Fetcher.default({
+      callType: _quizCommon.QUIZ_SAVE_CALL
+    });
+
+    if (action !== null) {
+      dispatch(action);
+    }
+
+    return fetcher.patch(url, params).then(function (response) {
+      dispatch((0, _callHandlers.handleQuizResponse)(response));
+    });
+  };
+}
+
+function setQuizShuffleQuestions(quizId, value) {
+  return setQuizProperty(quizId, {
+    shuffle_questions: Boolean(value)
+  }, (0, _modifications.changeQuizShuffleQuestions)(quizId, value));
+}
+
+function setQuizShuffleAnswers(quizId, value) {
+  return setQuizProperty(quizId, {
+    shuffle_answers: Boolean(value)
+  }, (0, _modifications.changeQuizShuffleAnswers)(quizId, value));
+}
+
+function setRequireStudentAccessCode(quizId, value) {
+  return setQuizProperty(quizId, {
+    require_student_access_code: Boolean(value)
+  }, (0, _modifications.changeQuizRequireStudentAccessCode)(quizId, value));
+}
+
+function setStudentAccessCodeUi(quizId, value) {
+  return function (dispatch, getState) {
+    dispatch((0, _modifications.changeQuizStudentAccessCode)(quizId, value));
+  };
+}
+
+function setStudentAccessCodeApi(quizId, value) {
+  return setQuizProperty(quizId, {
+    student_access_code: value
+  }, null);
+}
+
+function setOneAtATimeType(quizId, checked) {
+  var oneAtATimeType = checked ? 'question' : null;
+  return setQuizProperty(quizId, {
+    one_at_a_time_type: oneAtATimeType
+  }, (0, _modifications.changeQuizOneAtATimeType)(quizId, oneAtATimeType));
+}
+
+function setBacktracking(quizId, value) {
+  return setQuizProperty(quizId, {
+    allow_backtracking: Boolean(value)
+  }, (0, _modifications.changeQuizAllowBacktracking)(quizId, value));
+}
+
+function setQuizHasTimeLimit(quizId, value) {
+  return setQuizProperty(quizId, {
+    has_time_limit: Boolean(value)
+  }, (0, _modifications.changeQuizHasTimeLimit)(quizId, value));
+}
+
+function setSessionTimeLimitInSecondsUi(quizId, value) {
+  return function (dispatch, getState) {
+    dispatch((0, _modifications.changeSessionTimeLimitInSeconds)(quizId, value));
+  };
+}
+
+function setSessionTimeLimitInSecondsApi(quizId, value) {
+  return setQuizProperty(quizId, {
+    session_time_limit_in_seconds: value
+  }, null);
+}
+
+function setFilterIpAddress(quizId, value) {
+  return setQuizProperty(quizId, {
+    filter_ip_address: Boolean(value)
+  }, (0, _modifications.changeQuizFilterIpAddress)(quizId, value));
+}
+
+function setIpFiltersUi(quizId, value) {
+  return function (dispatch, getState) {
+    dispatch((0, _modifications.changeQuizIpFilters)(quizId, value));
+  };
+}
+
+function setIpFiltersApi(quizId, value) {
+  return setQuizProperty(quizId, {
+    filters: {
+      ips: value
+    }
+  }, null);
+}
+
+function setCalculatorType(quizId, value) {
+  return setQuizProperty(quizId, {
+    calculator_type: value
+  }, (0, _modifications.changeQuizCalculatorType)(quizId, value));
+}