@instructure/quiz-core 22.17.0 → 22.18.0

package/src/common/reducers/grading.js

@@ -0,0 +1,20 @@
+import {fromJS} from 'immutable'
+
+import {
+  DISMISS_GBQ_BANNER,
+  GRADE_BY_QUESTION_ENABLED,
+  GBQ_SET_ACTIVE_ITEM,
+} from '@instructure/quiz-common/constants'
+
+export default (state = fromJS({}), action) => {
+  switch (action.type) {
+    case GRADE_BY_QUESTION_ENABLED:
+      return state.set('gradeByQuestionEnabled', action.payload)
+    case GBQ_SET_ACTIVE_ITEM:
+      return state.set('activeItemId', action.payload)
+    case DISMISS_GBQ_BANNER:
+      return state.set('gradeByQuestionBannerDismissed', true)
+    default:
+      return state
+  }
+}

package/src/common/reducers/interactionTypes.js

@@ -0,0 +1,17 @@
+import {Map} from 'immutable'
+import keyBy from 'lodash/keyBy'
+
+import {ADD_INTERACTION_TYPES} from '@instructure/quiz-common/constants'
+
+const addTypes = (state, types) => {
+  return state.mergeDeep(keyBy(types, 'id'))
+}
+
+export default (state = Map(), action) => {
+  switch (action.type) {
+    case ADD_INTERACTION_TYPES:
+      return addTypes(state, action.payload)
+    default:
+      return state
+  }
+}

package/src/common/reducers/items.js

@@ -0,0 +1,19 @@
+import keyBy from 'lodash/keyBy'
+import {fromJS} from 'immutable'
+
+import {ADD_ITEMS} from '@instructure/quiz-common/constants'
+
+const addItems = (state, items) => {
+  const itemsHash = keyBy(items, 'id')
+  return state.merge(fromJS(itemsHash))
+}
+
+const defaultState = fromJS({})
+export default (state = defaultState, action) => {
+  switch (action.type) {
+    case ADD_ITEMS:
+      return addItems(state, action.payload)
+    default:
+      return state
+  }
+}

package/src/common/reducers/modal.js

@@ -0,0 +1,43 @@
+import {fromJS, Map} from 'immutable'
+
+import {
+  OPEN_ADD_CONTENT_MODAL,
+  OPEN_ADD_CONTENT_MODAL_DATA,
+  ADD_CONTENT_MODAL,
+  OPEN_DELETE_STIMULUS_MODAL,
+  DELETE_STIMULUS_MODAL,
+  OPEN_MOVE_IMMUTABLE_MODAL,
+  MOVE_IMMUTABLE_MODAL,
+  OPEN_MODAL,
+  CLOSE_MODAL,
+} from '@instructure/quiz-common/constants'
+
+export default (
+  state = fromJS({
+    OPEN_ADD_CONTENT_MODAL_DATA: {
+      allowStimulusCreation: false,
+      modalOpen: false,
+      position: 0,
+      quizId: '',
+      stimulusId: '',
+    },
+  }),
+  action,
+) => {
+  switch (action.type) {
+    case OPEN_DELETE_STIMULUS_MODAL:
+      return state.set('isOpen', DELETE_STIMULUS_MODAL)
+    case OPEN_ADD_CONTENT_MODAL:
+      return state
+        .set('isOpen', ADD_CONTENT_MODAL)
+        .set(OPEN_ADD_CONTENT_MODAL_DATA, Map(action.payload))
+    case OPEN_MOVE_IMMUTABLE_MODAL:
+      return state.set('isOpen', MOVE_IMMUTABLE_MODAL)
+    case OPEN_MODAL:
+      return state.set('isOpen', action.payload.title).set('options', Map(action.payload.options))
+    case CLOSE_MODAL:
+      return state.set('isOpen', false)
+    default:
+      return state
+  }
+}

package/src/common/reducers/moderation.js

@@ -0,0 +1,25 @@
+import {fromJS, List} from 'immutable'
+
+import {CLOSE_MODERATE_TRAY, OPEN_MODERATE_TRAY} from '@instructure/quiz-common/constants'
+
+const initialState = fromJS({
+  selectedParticipantName: null,
+  selectedSessions: List(),
+  trayOpen: false,
+})
+
+export default (state = initialState, action = {}) => {
+  switch (action.type) {
+    case CLOSE_MODERATE_TRAY:
+      return state.set('trayOpen', false)
+
+    case OPEN_MODERATE_TRAY:
+      return state
+        .set('selectedParticipantName', action.participant.name)
+        .set('selectedSessions', List(action.participant.quizSessionIds))
+        .set('trayOpen', true)
+
+    default:
+      return state
+  }
+}

package/src/common/reducers/modifications.js

@@ -0,0 +1,300 @@
+import {Map, fromJS} from 'immutable'
+
+import {
+  MOVE_TEMPORARY_ITEM,
+  TEMPORARY_ITEM_ID,
+  TEMPORARY_QUIZ_ENTRY_ID,
+  TEMPORARY_BANK_ENTRY_ID,
+  TEMPORARY_BANK_ID,
+  TEMPORARY_STIMULUS_ID,
+  CLEAR_NEXT_QUIZ_ENTRY,
+  CLEAR_TEMPORARY_ITEM,
+  CLEAR_TEMPORARY_BANK_ITEM,
+  CLEAR_TEMPORARY_STIMULUS,
+  CREATE_TEMPORARY_ITEM,
+  CREATE_TEMPORARY_BANK_ITEM,
+  CREATE_TEMPORARY_BANK,
+  CREATE_TEMPORARY_STIMULUS,
+  QUIZ_MODIFICATION,
+  BANK_MODIFICATION,
+  QUIZ_ENTRIES_MODIFICATION,
+  QUIZ_SESSION_RESULT_MODIFICATION,
+  ITEM_MODIFICATION,
+  STIMULUS_MODIFICATION,
+  CLEAR_MODIFICATIONS,
+  SET_NEXT_QUIZ_ENTRY,
+  SESSION_ITEM_RESULTS_MODIFICATION,
+} from '@instructure/quiz-common/constants'
+
+import {mergeDeepOnlyMaps} from '../util/immutableHelpers'
+import Stimulus from '../records/Stimulus'
+
+const defaultObjMods = (objId, keyAttr = 'id') => {
+  return Map({[keyAttr]: objId})
+}
+
+const mergeMods = (initialMods, modificationsMap) => {
+  return initialMods.merge(fromJS(modificationsMap))
+}
+
+const mergeModsDeep = (initialMods, modificationsMap) => {
+  return initialMods.mergeWith(mergeDeepOnlyMaps, fromJS(modificationsMap))
+}
+
+const updateObjectOfType = (
+  state,
+  key,
+  modifications,
+  objType,
+  {keyAttr = 'id', mergeFunc = mergeMods} = {},
+) => {
+  return state.updateIn([objType, key], defaultObjMods(key, keyAttr), obj =>
+    mergeFunc(obj, modifications),
+  )
+}
+
+const clearObject = (state, action) => {
+  return state.deleteIn(
+    [action.payload.objectType, action.payload.objectId].concat(action.payload.deepKeys),
+  )
+}
+
+const clearTemporaryEntry = (state, action, type, id) => {
+  return state
+    .setIn(['quizzes', action.payload.quizId, 'quizEntries'], [])
+    .deleteIn(['quizEntries', TEMPORARY_QUIZ_ENTRY_ID])
+    .deleteIn([type, id])
+}
+
+const clearTemporaryBankEntry = (state, action, type, id) => {
+  return state
+    .setIn(['banks', action.payload.bankId, 'bankEntries'], [])
+    .deleteIn(['bankEntries', TEMPORARY_BANK_ENTRY_ID])
+    .deleteIn([type, id])
+}
+
+export default (
+  state = fromJS({
+    banks: {},
+    items: {},
+    quizEntries: {},
+    quizzes: {},
+    sessionItemResults: {},
+  }),
+  action,
+) => {
+  switch (action.type) {
+    case BANK_MODIFICATION:
+      return updateObjectOfType(state, action.payload.id, action.payload.modifications, 'banks')
+    case QUIZ_MODIFICATION:
+      return updateObjectOfType(state, action.payload.id, action.payload.modifications, 'quizzes')
+    case ITEM_MODIFICATION:
+      return updateObjectOfType(state, action.payload.id, action.payload.modifications, 'items')
+    case QUIZ_ENTRIES_MODIFICATION:
+      return updateObjectOfType(
+        state,
+        action.payload.id,
+        action.payload.modifications,
+        'quizEntries',
+        {mergeFunc: mergeModsDeep},
+      )
+    case SET_NEXT_QUIZ_ENTRY:
+      return state.set('nextQuizEntry', Map(action.payload))
+    case QUIZ_SESSION_RESULT_MODIFICATION:
+      return updateObjectOfType(
+        state,
+        action.payload.id,
+        action.payload.modifications,
+        'quizSessionResults',
+      )
+    case SESSION_ITEM_RESULTS_MODIFICATION:
+      return updateObjectOfType(
+        state,
+        action.payload.id,
+        action.payload.modifications,
+        'sessionItemResults',
+        {keyAttr: 'id'},
+      )
+    case CREATE_TEMPORARY_BANK:
+      return updateObjectOfType(state, TEMPORARY_BANK_ID, {title: '', ...action.payload}, 'banks')
+    case STIMULUS_MODIFICATION:
+      return updateObjectOfType(
+        state,
+        action.payload.stimulus.id,
+        action.payload.stimulus,
+        'stimuli',
+      )
+    case CREATE_TEMPORARY_STIMULUS:
+      return (() => {
+        const stimulusQuizMods = {
+          quizEntries: [TEMPORARY_QUIZ_ENTRY_ID],
+        }
+
+        const stateWithStimulusQuizMods = updateObjectOfType(
+          state,
+          action.payload.quizId,
+          stimulusQuizMods,
+          'quizzes',
+        )
+
+        const tempStimulus = new Stimulus({
+          id: TEMPORARY_STIMULUS_ID,
+          passage: action.payload.isPassage,
+          ...(action.payload.isPassage && {orientation: 'top'}),
+        }).toJS()
+
+        const stateWithStimulusMods = updateObjectOfType(
+          stateWithStimulusQuizMods,
+          TEMPORARY_STIMULUS_ID,
+          tempStimulus,
+          'stimuli',
+        )
+
+        const stimulusPosition = action.payload.position === 0 ? 0.9 : action.payload.position - 0.1
+
+        const stimulusQuizEntryMods = {
+          position: stimulusPosition,
+          entry: TEMPORARY_STIMULUS_ID,
+          entryType: 'Stimulus',
+        }
+
+        return updateObjectOfType(
+          stateWithStimulusMods,
+          TEMPORARY_QUIZ_ENTRY_ID,
+          stimulusQuizEntryMods,
+          'quizEntries',
+        )
+      })()
+    case CREATE_TEMPORARY_ITEM:
+      return (() => {
+        const quizMods = {
+          quizEntries: [TEMPORARY_QUIZ_ENTRY_ID],
+        }
+
+        const stateWithQuizMods = updateObjectOfType(
+          state,
+          action.payload.quizId,
+          quizMods,
+          'quizzes',
+        )
+
+        const position = action.payload.position === 0 ? 0.9 : action.payload.position - 0.1
+
+        const {pointsPossible, interactionTypeData} = action.payload
+
+        const quizEntryMods = {
+          ...(pointsPossible != null && {pointsPossible}),
+          position: position,
+          entry: TEMPORARY_ITEM_ID,
+          entryType: 'Item',
+          stimulusQuizEntryId: action.payload.parentEntryId,
+        }
+
+        const stateWithQuizEntryMods = updateObjectOfType(
+          stateWithQuizMods,
+          TEMPORARY_QUIZ_ENTRY_ID,
+          quizEntryMods,
+          'quizEntries',
+        )
+
+        const itemMods = {
+          answerFeedback: interactionTypeData.answerFeedback,
+          calculatorType: interactionTypeData.calculatorType,
+          feedback: interactionTypeData.feedback,
+          interactionData: interactionTypeData.interactionData,
+          interactionType: interactionTypeData.id,
+          itemBody: interactionTypeData.itemBody,
+          outcomeAlignmentSetGuid: interactionTypeData.outcomeAlignmentSetGuid,
+          properties: interactionTypeData.properties,
+          scoringAlgorithm: interactionTypeData.scoringAlgorithm,
+          scoringData: interactionTypeData.scoringData,
+          title: interactionTypeData.title,
+          stimulusId: action.payload.stimulusId,
+        }
+        const stateWithAllMods = updateObjectOfType(
+          stateWithQuizEntryMods,
+          TEMPORARY_ITEM_ID,
+          itemMods,
+          'items',
+        )
+
+        return stateWithAllMods
+      })()
+    case CREATE_TEMPORARY_BANK_ITEM:
+      return (() => {
+        const bankMods = {
+          bankEntries: [TEMPORARY_BANK_ENTRY_ID],
+        }
+
+        const stateWithBankMods = updateObjectOfType(
+          state,
+          action.payload.bankId,
+          bankMods,
+          'banks',
+        )
+
+        const tempId =
+          action.payload.bankEntryType === 'Item' ? TEMPORARY_ITEM_ID : TEMPORARY_STIMULUS_ID
+
+        const bankEntryMods = {
+          entry: tempId,
+          entryType: action.payload.bankEntryType,
+        }
+
+        const stateWithBankEntryMods = updateObjectOfType(
+          stateWithBankMods,
+          TEMPORARY_BANK_ENTRY_ID,
+          bankEntryMods,
+          'bankEntries',
+        )
+
+        let bankItemMods
+        if (action.payload.bankEntryType === 'Item') {
+          bankItemMods = {
+            interactionData: action.payload.interactionTypeData.interactionData,
+            interactionType: action.payload.interactionTypeData.id,
+            itemBody: action.payload.interactionTypeData.itemBody,
+            properties: action.payload.interactionTypeData.properties,
+            scoringData: action.payload.interactionTypeData.scoringData,
+            title: null,
+          }
+        } else {
+          const isPassage = action.payload.interactionTypeData.passage
+          bankItemMods = isPassage ? {title: '', passage: true, orientation: 'top'} : {title: ''}
+        }
+
+        const collection = action.payload.bankEntryType === 'Item' ? 'items' : 'stimuli'
+        return updateObjectOfType(stateWithBankEntryMods, tempId, bankItemMods, collection)
+      })()
+    case CLEAR_NEXT_QUIZ_ENTRY:
+      return state.delete('nextQuizEntry')
+    case CLEAR_TEMPORARY_STIMULUS:
+      return clearTemporaryEntry(state, action, 'stimuli', TEMPORARY_STIMULUS_ID)
+    case CLEAR_TEMPORARY_ITEM:
+      return clearTemporaryEntry(state, action, 'items', TEMPORARY_ITEM_ID)
+    case CLEAR_TEMPORARY_BANK_ITEM:
+      return clearTemporaryBankEntry(state, action, 'items', TEMPORARY_ITEM_ID)
+    case CLEAR_MODIFICATIONS:
+      return clearObject(state, action)
+    case MOVE_TEMPORARY_ITEM:
+      return (() => {
+        const oldPosition = state.getIn(['quizEntries', TEMPORARY_QUIZ_ENTRY_ID, 'position'])
+        let newPosition
+        if (action.payload.direction) {
+          newPosition = action.payload.direction === 'up' ? oldPosition - 1 : oldPosition + 1
+        } else {
+          const offset = action.payload.movingDown ? 0.9 : -0.1
+          newPosition = action.payload.position + offset
+        }
+
+        const qeMods = {
+          position: newPosition,
+          stimulusQuizEntryId: action.payload.stimulusQuizEntryId,
+        }
+
+        return updateObjectOfType(state, TEMPORARY_QUIZ_ENTRY_ID, qeMods, 'quizEntries')
+      })()
+    default:
+      return state
+  }
+}

package/src/common/reducers/outcomes.js

@@ -0,0 +1,30 @@
+import {fromJS} from 'immutable'
+
+import {
+  SET_CONTEXT_UUID,
+  SET_OUTCOMES_ENDPOINT,
+  SET_OUTCOMES_TOKEN,
+  SET_EXTERNAL_ACCOUNT_UUID,
+} from '@instructure/quiz-common/constants'
+
+const defaultState = fromJS({
+  contextUuid: '',
+  outcomesEndpoint: '',
+  outcomesToken: '',
+  externalAccountUuid: '',
+})
+
+export default (state = defaultState, action) => {
+  switch (action.type) {
+    case SET_CONTEXT_UUID:
+      return state.set('contextUuid', action.payload)
+    case SET_OUTCOMES_ENDPOINT:
+      return state.set('outcomesEndpoint', action.payload)
+    case SET_OUTCOMES_TOKEN:
+      return state.set('outcomesToken', action.payload)
+    case SET_EXTERNAL_ACCOUNT_UUID:
+      return state.set('externalAccountUuid', action.payload)
+    default:
+      return state
+  }
+}

package/src/common/reducers/printing.js

@@ -0,0 +1,16 @@
+import {Map} from 'immutable'
+
+import {
+  SET_PRINT_FONT_SIZE_PREFERENCE,
+  PERSIST_PRINT_FONT_SIZE_PREFERENCE,
+} from '@instructure/quiz-common/constants'
+
+export default (state = Map(), action) => {
+  switch (action.type) {
+    case SET_PRINT_FONT_SIZE_PREFERENCE:
+    case PERSIST_PRINT_FONT_SIZE_PREFERENCE:
+      return state.set('fontSizePreference', action.fontSizePreference)
+    default:
+      return state
+  }
+}

package/src/common/reducers/qtiImports.js

@@ -0,0 +1,20 @@
+import keyBy from 'lodash/keyBy'
+import {Map, fromJS} from 'immutable'
+
+import {ADD_QTI_IMPORTS, CLEAR_QTI_IMPORTS} from '@instructure/quiz-common/constants'
+
+const addImports = (state, items) => {
+  const importsHash = keyBy(items, 'id')
+  return state.merge(fromJS(importsHash))
+}
+const defaultState = Map()
+export default (state = defaultState, action) => {
+  switch (action.type) {
+    case ADD_QTI_IMPORTS:
+      return addImports(state, action.payload)
+    case CLEAR_QTI_IMPORTS:
+      return defaultState
+    default:
+      return state
+  }
+}

package/src/common/reducers/quizEntries.js

@@ -0,0 +1,167 @@
+import {fromJS, Map} from 'immutable'
+import keyBy from 'lodash/keyBy'
+import isArrayLike from 'lodash/isArrayLike'
+
+import {
+  ADD_QUIZ_ENTRIES,
+  ADD_QUIZ_ENTRY,
+  DELETE_QUIZ_ENTRY,
+  DELETE_STIMULUS_ENTRY,
+  MOVE_QUIZ_ENTRY,
+  UPDATE_SAMPLE_ITEMS,
+} from '@instructure/quiz-common/constants'
+
+const addQuizEntries = (state, quizEntries) => {
+  const quizEntriesHash = keyBy(quizEntries, 'id')
+  return fromJS(quizEntriesHash)
+}
+
+const addQuizEntry = (state, quizEntry) => {
+  // This is sad, but because of how we handle our data in the
+  // getPersistenceActions/CallHandlers all of our data will be
+  // arrays coming in to the store from fetcher, even if it
+  // _should_ be a single object.
+  const qe = isArrayLike(quizEntry) ? keyBy(quizEntry, 'id') : {[quizEntry.id]: quizEntry}
+  return state.mergeDeep(fromJS(qe))
+}
+
+const deleteQuizEntry = (state, {id}) => {
+  const deletedEntry = state.get(id)
+  const stateWithoutDeletedEntry = state.delete(id)
+
+  // Adjust the positions of subsequent quiz entries, to fill in the gap left
+  // by the one we're deleting.
+  const moved = stateWithoutDeletedEntry
+    .filter(entry => entry.get('position') > deletedEntry.get('position'))
+    .map(entry => entry.set('position', entry.get('position') - 1))
+
+  return stateWithoutDeletedEntry.merge(moved)
+}
+
+const deleteStimulusEntry = (state, {id, childQuizEntryIds = []}) => {
+  const stimulusEntry = state.get(id)
+  // TODO: use deleteAll here after upgrading to immutable 4:
+  // http://facebook.github.io/immutable-js/docs/#/Map/deleteAll
+  const stateWithoutDeletedEntries = childQuizEntryIds.reduce(
+    (reduced, childQuizEntryId) => reduced.delete(childQuizEntryId),
+    state.delete(id),
+  )
+
+  // Disassociate any quiz entries that were associated with the stimulus, but
+  // not deleted along with it.
+  const disassociated = stateWithoutDeletedEntries.map(entry =>
+    entry.get('stimulusQuizEntryId') === id ? entry.set('stimulusQuizEntryId', '') : entry,
+  )
+
+  // Adjust the positions of all the quiz entries that were associated with the
+  // removed stimulus and were not deleted along with it, as well as all
+  // subsequent entries, to fill in the gap left by the removed stimulus.
+  const moved = disassociated
+    .valueSeq()
+    .filter(entry => entry.get('position') > stimulusEntry.get('position'))
+    .sortBy(entry => entry.get('position'))
+    .map((entry, index) => entry.set('position', stimulusEntry.get('position') + index))
+    .reduce((entries, entry) => entries.set(entry.get('id'), entry), Map())
+
+  return disassociated.merge(moved)
+}
+
+const moveQuizEntry = (state, {id, position, stimulusQuizEntryId}) => {
+  const originalQuizEntry = state.get(id)
+  const originalPosition = originalQuizEntry.get('position')
+  const originalIsStimulus = originalQuizEntry.get('entryType') === 'Stimulus'
+
+  // We shouldn't be trying to move a stimulus into itself, this should
+  // not happen, but let's be safe.
+  if (originalIsStimulus && stimulusQuizEntryId.length != 0) {
+    return state
+  }
+
+  const updatedQuizEntry = originalQuizEntry.merge({stimulusQuizEntryId})
+  const updatedState = state.set(id, updatedQuizEntry)
+
+  // If the position hasn't changed, we might still be moving the entry into or
+  // out of a stimulus.
+  if (position === originalPosition) {
+    return updatedState
+  }
+
+  // Now we need to rearrange positions to account for the move
+  // If the quizEntry is a stimulus,  we'll need to move its children as well
+  const nestedEntries =
+    updatedQuizEntry.get('entryType') === 'Stimulus'
+      ? updatedState.filter(entry => entry.get('stimulusQuizEntryId') === id)
+      : Map()
+  const movedEntries = nestedEntries.set(id, updatedQuizEntry)
+  const maxOriginalPosition = movedEntries.map(entry => entry.get('position')).max()
+
+  if (position > originalPosition && position <= maxOriginalPosition) {
+    // trying to move to a position currently inside itself
+    // and we can't do that
+    return updatedState
+  }
+
+  // We're really just interested in the affected range:
+  // ..., (a, b, c), x, y, ...
+  // ..., x, y, (a, b, c), ...
+  // where (a, b, c) are the entries we're trying to *move*, and x, y are the entries
+  // that are *displaced*
+  //  - The moved entries increase their index by the number of entries that are displaced
+  //  - The displaced entries decrease their index by the number of entries that are moved
+  // The operation is symmetric (just swap increase/decrease in the lines above)
+  // Ranges
+  //  - moving farther to the right in the list:
+  //      moved:     [originalPosition, maxOriginalPosition]
+  //      displaced: [maxOriginalPosition + 1, position]
+  //      affected:  [originalPosition, position]
+  //  - moving farther to the left the list:
+  //      moved:     [originalPosition, maxOriginalPosition]
+  //      displaced: [position, originalPosition - 1]
+  //      affected:  [position, maxOriginalPosition]
+
+  const start = Math.min(originalPosition, position)
+  const end = Math.max(maxOriginalPosition, position)
+  const numMoved = maxOriginalPosition - originalPosition + 1
+  const numDisplaced = end - start - numMoved + 1
+
+  const direction = position > originalPosition ? 1 : -1
+
+  return updatedState.map(entry => {
+    const pos = entry.get('position')
+    if (pos >= start && pos <= end) {
+      if (pos >= originalPosition && pos <= maxOriginalPosition) {
+        // moved entries
+        return entry.set('position', pos + numDisplaced * direction)
+      } else {
+        // displaced entries
+        return entry.set('position', pos - numMoved * direction)
+      }
+    } else {
+      // out of range entries
+      return entry
+    }
+  })
+}
+
+const updateSampleItems = (state, {id, sampleItems}) => {
+  return state.setIn([id, 'sampleItems'], sampleItems)
+}
+
+export default (state = Map(), action) => {
+  switch (action.type) {
+    case ADD_QUIZ_ENTRIES:
+      return addQuizEntries(state, action.payload)
+    case ADD_QUIZ_ENTRY:
+      return addQuizEntry(state, action.payload)
+    case DELETE_QUIZ_ENTRY:
+      return deleteQuizEntry(state, action.payload)
+    case DELETE_STIMULUS_ENTRY:
+      return deleteStimulusEntry(state, action.payload)
+    case MOVE_QUIZ_ENTRY:
+      return moveQuizEntry(state, action.payload)
+    case UPDATE_SAMPLE_ITEMS:
+      return updateSampleItems(state, action.payload)
+    default:
+      return state
+  }
+}

package/src/common/reducers/quizExport.js

@@ -0,0 +1,11 @@
+import {START_QUIZ_EXPORT_JOB} from '@instructure/quiz-common/constants'
+import {fromJS} from 'immutable'
+
+export default (state = fromJS({}), action) => {
+  switch (action.type) {
+    case START_QUIZ_EXPORT_JOB:
+      return state.set(`activeQuiz${action.payload}`, true)
+    default:
+      return state
+  }
+}