@instructure/quiz-core 22.17.0 → 22.18.0

package/src/common/react-redux.js

@@ -0,0 +1,65 @@
+/* eslint "no-param-reassign": "warn" */
+import React, {createContext, useContext, useState, useEffect} from 'react'
+import {
+  connect,
+  createDispatchHook,
+  createSelectorHook,
+  createStoreHook,
+  Provider as ReduxProvider,
+} from 'react-redux'
+
+export const SDKReduxContext = createContext(null)
+
+export const useSDKDispatch = createDispatchHook(SDKReduxContext)
+export const useSDKSelector = createSelectorHook(SDKReduxContext)
+export const useSDKReduxStore = createStoreHook(SDKReduxContext)
+
+let _globalStore = null
+const _listeners = new Set()
+
+export function getGlobalSDKStore() {
+  return _globalStore
+}
+
+export function setGlobalSDKStore(store) {
+  _globalStore = store
+  _listeners.forEach(fn => fn(store))
+}
+
+/**
+ * Returns the SDK store. Prefers the React Context value (available inside
+ * SDKApp's SDKStoreProvider tree), falls back to the module-level global store for
+ * components rendered outside the SDKStoreProvider (e.g. SDKBuildingButtons in Page header).
+ *
+ * Components outside the SDKStoreProvider re-render when setGlobalSDKStore() is called.
+ */
+export function useSDKStore() {
+  const reduxCtx = useContext(SDKReduxContext)
+  const [globalStore, setGlobalStore] = useState(_globalStore)
+
+  useEffect(() => {
+    // Sync in case _globalStore was set between render and effect
+    if (_globalStore !== globalStore) {
+      setGlobalStore(_globalStore)
+    }
+    _listeners.add(setGlobalStore)
+    return () => _listeners.delete(setGlobalStore)
+  }, []) // eslint-disable-line react-hooks/exhaustive-deps
+
+  return reduxCtx?.store || globalStore
+}
+
+function connectToSDKStore(mapStateToProps, mapDispatchToProps, mergeProps, options = {}) {
+  options.context = options.context || SDKReduxContext
+  return connect(mapStateToProps, mapDispatchToProps, mergeProps, options)
+}
+
+export {connectToSDKStore as connect}
+
+export function SDKStoreProvider({store, children}) {
+  return (
+    <ReduxProvider store={store} context={SDKReduxContext}>
+      {children}
+    </ReduxProvider>
+  )
+}

package/src/common/records/Alert.ts

@@ -0,0 +1,11 @@
+// @ts-nocheck
+import ReduxRecord from './reduxRecord'
+
+export class Alert extends ReduxRecord({
+  message: null,
+  uuid: null,
+  variant: 'info',
+  politeness: 'assertive',
+}) {}
+
+export default Alert

package/src/common/records/Bank.ts

@@ -0,0 +1,79 @@
+// @ts-nocheck
+import {Set} from 'immutable'
+
+import ReduxRecord from './reduxRecord'
+import t from '@instructure/quiz-i18n/format-message'
+import {TEMPORARY_BANK_ID, CAN_EDIT} from '@instructure/quiz-common/constants'
+import {rule} from 'instructure-validations'
+import {presenceMessage} from '@instructure/quiz-interactions/util/validationHelpers'
+import {getLatestQtiImportForParentWithType} from '../selectors/qtiImports'
+
+export class Bank extends ReduxRecord({
+  accountPermission: null,
+  archived: false,
+  bankEntries: Set(),
+  createdAt: null,
+  entryCount: 0, // item count + stimulus count
+  filters: null,
+  id: '0',
+  itemEntryCount: 0, // item count only
+  language: null,
+  creator: '',
+  permission: '',
+  sharedCount: 0,
+  status: null,
+  title: '',
+  updatedAt: null,
+  lastUpdated: null,
+  lastUsed: null,
+}) {
+  static validations() {
+    return {
+      title: [rule('presence', {message: presenceMessage(t('Bank name'))})],
+    }
+  }
+
+  createdAt() {
+    return new Date(this.get('createdAt'))
+  }
+
+  updatedAt() {
+    return new Date(this.get('updatedAt'))
+  }
+
+  lastUsed() {
+    const lastUsed = this.get('lastUsed')
+    return lastUsed ? new Date(lastUsed) : null
+  }
+
+  isLoaded() {
+    return this.id !== '0'
+  }
+
+  isTemporary() {
+    return this.id === TEMPORARY_BANK_ID
+  }
+
+  getWorkingInstance() {
+    const data = this.merge(this.getState().modifications.getIn(['banks', this.id]))
+    return Bank.create(data)
+  }
+
+  hasModifications() {
+    return false
+  }
+
+  canImport() {
+    return this.status === 'waiting' && this.entryCount === 0
+  }
+
+  getLatestImport() {
+    return getLatestQtiImportForParentWithType(this.getState(), this.id, 'Bank')
+  }
+
+  canEdit() {
+    return this.permission === CAN_EDIT
+  }
+}
+
+export default Bank

package/src/common/records/BankEntry.ts

@@ -0,0 +1,68 @@
+// @ts-nocheck
+import {Map} from 'immutable'
+import ReduxRecord from './reduxRecord'
+import Item from './Item'
+import Stimulus from './Stimulus'
+import {TEMPORARY_ITEM_ID, TEMPORARY_STIMULUS_ID} from '@instructure/quiz-common/constants'
+
+export class BankEntry extends ReduxRecord({
+  id: '0',
+  entry: Map(),
+  bankId: '0',
+  archived: false,
+  entryType: null,
+  createdAt: null,
+  updatedAt: null,
+}) {
+  getEntry() {
+    if (this.entry === TEMPORARY_ITEM_ID) {
+      return Item.create(this.getState().modifications.getIn(['items', TEMPORARY_ITEM_ID]))
+    }
+    if (this.entry === TEMPORARY_STIMULUS_ID) {
+      return Stimulus.create(
+        this.getState().modifications.getIn(['stimuli', TEMPORARY_STIMULUS_ID]),
+      )
+    }
+
+    const entryCreator = {
+      Item: () => Item.create(this.getState().items.get(this.entry.get('id'))),
+      Stimulus: () => Stimulus.create(this.getState().stimuli.get(this.entry.get('id'))),
+    }[this.entryType]
+    if (entryCreator) return entryCreator()
+  }
+
+  getNestedEntries() {
+    const entry = this.getEntry()
+    const getNestedEntriesFunction = {
+      Item: () => [entry],
+    }[this.entryType]
+    if (getNestedEntriesFunction) return getNestedEntriesFunction()
+  }
+
+  getWorkingInstance() {
+    return this.merge(this.getState().modifications.getIn(['bankEntries', this.id]))
+  }
+
+  get isStimulus() {
+    return this.entryType === 'Stimulus' && !this.getEntry()?.isPassage
+  }
+
+  get isPassage() {
+    if (!this.isStimulus) return false
+    return this.getEntry()?.isPassage
+  }
+
+  get isStimulusEntry() {
+    const entry = this.getEntry()
+    if (!entry) return false
+    return entry.isStimulus && !entry.isPassage
+  }
+
+  get isPassageEntry() {
+    const entry = this.getEntry()
+    if (!entry) return false
+    return entry.isStimulus && entry.isPassage
+  }
+}
+
+export default BankEntry

package/src/common/records/Item.ts

@@ -0,0 +1,119 @@
+// @ts-nocheck
+import {fromJS, Map, is} from 'immutable'
+import {default as InteractionTypeRecord} from '@instructure/quiz-interactions/records/InteractionType'
+
+import t from '@instructure/quiz-i18n/format-message'
+import {rule} from 'instructure-validations'
+import {
+  TEMPORARY_ITEM_ID,
+  BUILD_CHAR_LIMIT,
+  RICH_FILL_BLANK_SLUG,
+} from '@instructure/quiz-common/constants'
+import ReduxRecord from './reduxRecord'
+import {getInteractionType} from '../selectors/interactionTypes'
+
+export class Item extends ReduxRecord({
+  id: '0',
+  title: t('Title'),
+  label: t('label'),
+  itemBody: t('Question stem'),
+  interactionTypeId: '0',
+  interactionType: '0',
+  interactionData: Map(),
+  properties: Map(),
+  contextId: null,
+  toolName: null,
+  parentItemId: null,
+  parentItemRelationship: null,
+  createdAt: null,
+  updatedAt: null,
+  scoringAlgorithm: null,
+  scoringData: Map(),
+  scoringDataSchema: Map(),
+  status: 'mutable',
+  outcomeDeclaration: null,
+  outcomeAlignmentSetGuid: null,
+  feedback: Map(),
+  answerFeedback: Map(),
+  stimulusId: null,
+  calculatorType: 'none',
+  metadata: Map(),
+}) {
+  static validations() {
+    return {
+      onSelf: [rule('maxContent', {limit: BUILD_CHAR_LIMIT})],
+    }
+  }
+
+  get isStimulus() {
+    return false
+  }
+
+  isLoaded() {
+    return this.id !== '0'
+  }
+
+  hasResponse(userResponse) {
+    if (!userResponse || userResponse.value === null || userResponse.value === void 0) return false
+    return this.getInteractionType().hasResponse(userResponse.value, this.interactionData.toJS())
+  }
+
+  getChoice(choiceId) {
+    return this.getIn(['interactionData', 'choices'], fromJS([])).find(choice => {
+      return choice.get('id') === choiceId
+    })
+  }
+
+  getInteractionType() {
+    // if the interaction type wasn't normalized (sample items), we need to get the id from the object
+    const interactionTypeId =
+      typeof this.interactionType === 'object' ? this.interactionType.id : this.interactionType
+    return getInteractionType(this.getState(), interactionTypeId) || new InteractionTypeRecord()
+  }
+
+  getItemBody() {
+    if (this.getInteractionType().slug === RICH_FILL_BLANK_SLUG && this.itemBody) {
+      return this.itemBody.split(/(?=<span id="blank_)/g).join('_____')
+    }
+    return this.itemBody
+  }
+
+  hasModifications() {
+    return !is(this.getWorkingInstance(), this)
+  }
+
+  hasFeedback() {
+    return (
+      this.getIn(['feedback', 'correct']) ||
+      this.getIn(['feedback', 'incorrect']) ||
+      this.getIn(['feedback', 'neutral'])
+    )
+  }
+
+  getScoringAlgorithm() {
+    return this.scoringAlgorithm || this.getInteractionType().scoringAlgorithmDefault
+  }
+
+  getWorkingInstance(overrides) {
+    const mods = this.getState().modifications.getIn(['items', this.id])
+    const data = this.merge(overrides, mods)
+    // needed so we can maintain state... this is sad
+    return Item.create(data, this.getState())
+  }
+
+  isImmutable() {
+    return this.status === 'immutable'
+  }
+
+  isTemporary() {
+    return this.id === TEMPORARY_ITEM_ID
+  }
+
+  // PRIVATE METHODS
+
+  __defaultItem() {
+    return this.id === '0'
+  }
+}
+
+export default Item

package/src/common/records/ItemAnalysis.ts

@@ -0,0 +1,125 @@
+// @ts-nocheck
+import {List, Map} from 'immutable'
+import {max as d3max, sum as d3sum} from 'd3-array'
+
+import {formatDecimal2FractionDigits} from '@instructure/quiz-i18n/util/numberFormats'
+
+import ReduxRecord from './reduxRecord'
+import {interactionTypeMetadata} from '../util/interactionTypeMetadata'
+
+export class ItemAnalysis extends ReduxRecord({
+  itemId: '0',
+  quizId: '0',
+  pointsPossible: '0',
+  interactionType: null,
+  itemBody: null,
+  itemAnalysis: null,
+  notFound: false,
+  outcomeAlignmentSetGuid: null,
+}) {
+  isLoaded() {
+    return this.itemId !== '0'
+  }
+
+  interactionTypeName() {
+    const intData = interactionTypeMetadata({slug: this.interactionType})
+    return intData.name
+  }
+
+  correctAnswerInfo() {
+    return this.itemAnalysis.get('correctAnswerInfo', Map())
+  }
+
+  incorrectAnswerInfo() {
+    return this.itemAnalysis.get('incorrectAnswerInfo', Map())
+  }
+
+  isPresent() {
+    return !this.notFound
+  }
+
+  scoreInfo() {
+    return this.itemAnalysis.get('scoreInfo', Map())
+  }
+
+  choiceInfo() {
+    return this.itemAnalysis.get('choiceInfo', List())
+  }
+
+  topCorrectAnswerInfo() {
+    return this.itemAnalysis.get('topCorrectAnswerInfo', Map())
+  }
+
+  bottomCorrectAnswerInfo() {
+    return this.itemAnalysis.get('bottomCorrectAnswerInfo', Map())
+  }
+
+  unansweredInfo() {
+    return this.itemAnalysis.get('unansweredInfo', 0)
+  }
+
+  quintile() {
+    return this.itemAnalysis.get('quintile', List([0, 0, 0, 0, 0])).toJS()
+  }
+
+  choiceCounts() {
+    return this.choiceInfo()
+      .toJS()
+      .map(c => {
+        return c.choiceCount
+      })
+      .concat(this.unansweredInfo())
+  }
+
+  choiceCountMax() {
+    return d3max(this.choiceCounts())
+  }
+
+  choiceCountSum() {
+    return d3sum(this.choiceCounts())
+  }
+
+  calculateMeanScore(scoreInfo) {
+    const sum = scoreInfo.get('resultSum') || 0
+    const count = scoreInfo.get('resultCount') || 0
+    return sum / count
+  }
+
+  calculateDifficultyRatio(correctAnswerInfo) {
+    const correctAnswerCount = correctAnswerInfo.get('resultCount') || 0
+    const appearedCount = correctAnswerInfo.get('appearedCount') || 0
+    return correctAnswerCount / appearedCount
+  }
+
+  formatDecimal(value, locale) {
+    return isFinite(value) ? formatDecimal2FractionDigits(value, locale) : null
+  }
+
+  meanScore(locale) {
+    return this.formatDecimal(this.calculateMeanScore(this.scoreInfo()), locale)
+  }
+
+  difficultyIndex(locale) {
+    return this.formatDecimal(this.calculateDifficultyRatio(this.correctAnswerInfo()), locale)
+  }
+
+  pointBiserial(locale) {
+    const correctMean = this.calculateMeanScore(this.correctAnswerInfo())
+    const incorrectMean = this.calculateMeanScore(this.incorrectAnswerInfo())
+    const stdDeviation = this.scoreInfo().get('scoreStddevPop')
+    const numCorrect = this.correctAnswerInfo().get('resultCount')
+    const numInCorrect = this.incorrectAnswerInfo().get('resultCount')
+    const totalTakers = this.correctAnswerInfo().get('appearedCount')
+    const firstTerm = (correctMean - incorrectMean) / stdDeviation
+    const secondTerm = Math.sqrt((numCorrect * numInCorrect) / (totalTakers * totalTakers))
+    return this.formatDecimal(firstTerm * secondTerm, locale)
+  }
+
+  discriminationIndex(locale) {
+    const topDifficulty = this.calculateDifficultyRatio(this.topCorrectAnswerInfo())
+    const bottomDifficulty = this.calculateDifficultyRatio(this.bottomCorrectAnswerInfo())
+    return this.formatDecimal(topDifficulty - bottomDifficulty, locale)
+  }
+}
+
+export default ItemAnalysis

package/src/common/records/QtiImport.ts

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import ReduxRecord from './reduxRecord'
+
+export class QtiImport extends ReduxRecord({
+  id: 0,
+  quizId: null,
+  status: null,
+  url: null,
+  message: null,
+  progress: 0.0,
+}) {
+  progressNumber() {
+    switch (this.status) {
+      case 'importing':
+        return this.progress
+      case 'completed':
+        return 1.0
+      default: // Scheduled, failed
+        return 0.0
+    }
+  }
+
+  isImporting() {
+    return this.status === 'importing'
+  }
+}
+
+export default QtiImport

package/src/common/records/Quiz.ts

@@ -0,0 +1,157 @@
+// @ts-nocheck
+import {List, Map} from 'immutable'
+import {rule} from 'instructure-validations'
+import {presenceMessage} from '@instructure/quiz-interactions/util/validationHelpers'
+import t from '@instructure/quiz-i18n/format-message'
+import QuizAnalysis from './QuizAnalysis'
+import ReduxRecord from './reduxRecord'
+
+import withStateCache from '../util/withStateCache'
+import {getQuizSessionById} from '../selectors/quizSessions'
+import {getQuizEntriesByIds} from '../selectors/quizzes'
+import {getLatestQtiImportForParentWithType} from '../selectors/qtiImports'
+import {getItemAnalysesByIds} from '../selectors/reporting'
+
+export class Quiz extends ReduxRecord({
+  allowBacktracking: true,
+  allowClearMcSelection: false,
+  calculatorType: 'none',
+  choiceElimination: false,
+  contextId: null,
+  defaultRceSettings: null,
+  detectMultipleSessions: false,
+  disableDocumentAccess: false,
+  hasTimeLimit: false,
+  id: '0',
+  instructions: t('Add Instructions...'),
+  itemAnalyses: List(),
+  items: List(),
+  oneAtATimeType: null,
+  originalQuizLockedByBlueprint: true,
+  outcomeAlignmentSetGuid: null,
+  owner: null,
+  quizAnalysis: '0',
+  quizEntries: List(),
+  quizEntriesCount: 0,
+  requireStudentAccessCode: false,
+  resultsFeedback: null,
+  resultsFeedbackEnabled: false,
+  sessionTimeLimitInSeconds: null,
+  shuffleAnswers: false,
+  shuffleQuestions: false,
+  status: null,
+  studentAccessCode: null,
+  title: t('Add Title...'),
+  filterIpAddress: false,
+  filters: Map(),
+  valid: true,
+  quizType: null,
+}) {
+  static validations() {
+    return {
+      title: [rule('presence', {message: presenceMessage(t('Quiz title'))})],
+    }
+  }
+
+  getTimeLimit() {
+    return this.hasTimeLimit ? this.sessionTimeLimitInSeconds : 0
+  }
+
+  getQuizSessions() {
+    return this.getState()
+      .quizSessions.filter(data => data.get('quiz') === this.id)
+      .map(qsd => getQuizSessionById(this.getState(), qsd.get('id')))
+      .valueSeq()
+      .toList()
+  }
+
+  getQuizSessionsForUser(userId) {
+    return this.getQuizSessions().filter(quizSession => {
+      return quizSession.getIn(['user', 'id']) === userId
+    })
+  }
+
+  @withStateCache(quiz => [['quizEntries'], ['modifications', 'quizEntries']])
+  getQuizEntries() {
+    return getQuizEntriesByIds(this.getState(), this.quizEntries).sortBy(qe => qe.position)
+  }
+
+  hasQuestions() {
+    return this.getQuizEntries().some(qe => !qe.hasStimulus)
+  }
+
+  getItemAnalyses() {
+    // TODO: Sort this based on the ordering on the quiz build page
+    return getItemAnalysesByIds(this.getState(), this.itemAnalyses)
+  }
+
+  getQuizAnalysis() {
+    return new QuizAnalysis(this.getState().reporting.getIn(['quiz_analysis', this.quizAnalysis]))
+  }
+
+  // If you call this.getWorkingInstance().getQuizEntries() manually, then
+  // changes to the other parts of a quiz (e.g., changing the title) will
+  // invalidate the cache, since the result of getWorkingInstance() will
+  // be a new object. This method explicitly caches by only the fields that are
+  // relevant to the working quiz entries.
+  @withStateCache(quiz => [
+    ['quizEntries'],
+    ['modifications', 'quizEntries'],
+    ['modifications', 'quizzes', quiz.id, 'quizEntries'],
+  ])
+  getWorkingQuizEntries() {
+    return this.getWorkingInstance().getQuizEntries()
+  }
+
+  @withStateCache(quiz => [['modifications', 'quizzes']])
+  getWorkingInstance() {
+    const modData = this.getState().modifications.getIn(['quizzes', this.id]) || Map()
+    const data = this.merge(
+      modData.update(
+        'quizEntries',
+        List(), // default
+        qi => {
+          // without custom merge, quizEntries List will be
+          // overwritten completely, and wouldnt' support
+          // temporary quizEntry associations well
+          return qi.concat(this.quizEntries.toJS())
+        },
+      ),
+    )
+
+    return Quiz.create(data, this.getState())
+  }
+
+  getLatestImport() {
+    return getLatestQtiImportForParentWithType(this.getState(), this.id, 'Quiz')
+  }
+
+  isLoaded() {
+    return this.id !== '0'
+  }
+
+  isImporting() {
+    return this.status === 'importing'
+  }
+
+  canImport() {
+    // associating the quizEntry will change the quiz status in the
+    // db but it wont return this info, we we'll check the quizEntry
+    // count in addition to the status
+    return this.status === 'uninitialized' && this.quizEntries.size === 0
+  }
+
+  isOneQuestionAtATime() {
+    return this.oneAtATimeType === 'question'
+  }
+
+  isSurvey() {
+    return this.quizType === 'ungraded_survey' || this.quizType === 'graded_survey'
+  }
+
+  state() {
+    return this.getState()
+  }
+}
+
+export default Quiz