@instructure/quiz-core 20.28.0 → 20.28.1-snapshot.1

package/es/reporting/components/resources/StudentAnalysis/ReportCard/presenter.js

@@ -0,0 +1,164 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+var _dec, _class, _StudentAnalysisReportCardPresenter;
+/** @jsx jsx */
+import { Component } from 'react';
+import { Text } from '@instructure/ui-text';
+import { Link } from '@instructure/ui-link';
+import { Flex } from '@instructure/ui-flex';
+import { ScreenReaderContent } from '@instructure/ui-a11y-content';
+import { withStyle, jsx } from '@instructure/emotion';
+import PropTypes from 'prop-types';
+import t from '@instructure/quiz-i18n/es/format-message';
+import Card from "../../../../../common/components/shared/Card/index.js";
+import { generateStyle } from "./styles.js";
+import { generateComponentTheme } from "./theme.js";
+import { ExportButton } from "../../common/ExportButton/index.js";
+import Spinner from "../../../../../common/components/shared/spinner/Spinner.js";
+import { STUDENT_ANALYSES } from '@instructure/quiz-common';
+import { studentAnalysesPropType } from "../../common/propTypes.js";
+import { AnalysisUpdateDate } from "../../common/AnalysisUpdateDate/index.js";
+export var StudentAnalysisReportCardPresenter = (_dec = withStyle(generateStyle, generateComponentTheme), _dec(_class = (_StudentAnalysisReportCardPresenter = /*#__PURE__*/function (_Component) {
+  _inherits(StudentAnalysisReportCardPresenter, _Component);
+  var _super = _createSuper(StudentAnalysisReportCardPresenter);
+  function StudentAnalysisReportCardPresenter() {
+    var _this;
+    _classCallCheck(this, StudentAnalysisReportCardPresenter);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _this.renderSpinner = function (mainText) {
+      return jsx("div", {
+        css: _this.props.styles.emptyCardBodyContainer
+      }, jsx(Flex, {
+        direction: "row"
+      }, jsx(Flex.Item, null, jsx(Spinner, {
+        size: "x-small",
+        color: "brand",
+        minHeight: "0",
+        mainText: mainText,
+        fontSize: "x-small",
+        "data-automation": "sdk-new-sa-report-card-spinner"
+      }))));
+    };
+    _this.handleExport = function (_event) {
+      _this.props.exportReport('csv', 'last_attempt', STUDENT_ANALYSES);
+    };
+    _this.handleGeneration = function (_event) {
+      _this.props.generateReport('last_attempt', STUDENT_ANALYSES);
+    };
+    _this.renderExportButton = function () {
+      var _this$props = _this.props,
+        studentAnalyses = _this$props.studentAnalyses,
+        generationInProgress = _this$props.generationInProgress;
+      return jsx(ExportButton, {
+        enabled: !generationInProgress && studentAnalyses,
+        handleExport: _this.handleExport
+      });
+    };
+    _this.renderGenerateReportButton = function () {
+      return jsx(Link, {
+        onClick: _this.handleGeneration,
+        role: "button",
+        "data-automation": "sdk-new-sa-report-card-generate-report-button"
+      }, jsx(ScreenReaderContent, null, t('Generate Student Analysis Report')), jsx(Text, {
+        size: "small",
+        "aria-hidden": "true"
+      }, t('Generate Report')));
+    };
+    _this.renderReportCardHeader = function () {
+      var _this$props2 = _this.props,
+        name = _this$props2.name,
+        exportEnabled = _this$props2.exportEnabled,
+        fetchInProgress = _this$props2.fetchInProgress;
+      return jsx("div", {
+        css: _this.props.styles.titleContainer
+      }, jsx(Flex, {
+        direction: "row",
+        wrap: "wrap",
+        justifyItems: "space-between"
+      }, jsx(Flex.Item, null, jsx(Text, {
+        size: "medium",
+        weight: "bold"
+      }, name)), exportEnabled && !fetchInProgress && jsx(Flex.Item, null, _this.renderExportButton())));
+    };
+    _this.renderReportCardFooter = function () {
+      var _this$props3 = _this.props,
+        generationInProgress = _this$props3.generationInProgress,
+        analysisError = _this$props3.analysisError;
+      return jsx("div", {
+        css: _this.props.styles.emptyCardBodyContainer
+      }, jsx(Flex, {
+        direction: "row",
+        justifyItems: "space-between"
+      }, jsx(Flex.Item, {
+        shouldShrink: true,
+        size: analysisError && !generationInProgress ? '40%' : null
+      }, analysisError && !generationInProgress && jsx(Text, {
+        size: "x-small",
+        weight: "bold",
+        color: "danger"
+      }, analysisError)), jsx(Flex.Item, {
+        shouldShrink: analysisError && !generationInProgress
+      }, generationInProgress ? _this.renderSpinner(t('Generation In Progress')) : _this.renderGenerateReportButton())));
+    };
+    _this.renderDateBlock = function () {
+      var studentAnalyses = _this.props.studentAnalyses;
+      return jsx("div", {
+        css: _this.props.styles.studentAnalysesSummary
+      }, jsx(Flex, {
+        direction: "row",
+        justifyItems: "space-between"
+      }, jsx("div", {
+        css: _this.props.styles.dateContainer
+      }, jsx(AnalysisUpdateDate, {
+        date: studentAnalyses.created_timestamp,
+        multiline: true
+      }))));
+    };
+    return _this;
+  }
+  _createClass(StudentAnalysisReportCardPresenter, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.props.makeStyles();
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate() {
+      this.props.makeStyles();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props4 = this.props,
+        studentAnalyses = _this$props4.studentAnalyses,
+        fetchInProgress = _this$props4.fetchInProgress,
+        styles = _this$props4.styles;
+      return jsx(Card, {
+        css: styles.reportCard,
+        customStyles: styles.reportCard
+      }, this.renderReportCardHeader(), !fetchInProgress && studentAnalyses && this.renderDateBlock(), fetchInProgress && this.renderSpinner(), !fetchInProgress && this.renderReportCardFooter());
+    }
+  }]);
+  StudentAnalysisReportCardPresenter.displayName = "StudentAnalysisReportCardPresenter";
+  return StudentAnalysisReportCardPresenter;
+}(Component), _StudentAnalysisReportCardPresenter.propTypes = {
+  name: PropTypes.node,
+  studentAnalyses: studentAnalysesPropType,
+  fetchInProgress: PropTypes.bool.isRequired,
+  generationInProgress: PropTypes.bool.isRequired,
+  exportEnabled: PropTypes.bool.isRequired,
+  analysisError: PropTypes.string,
+  generateReport: PropTypes.func.isRequired,
+  exportReport: PropTypes.func.isRequired,
+  styles: PropTypes.object,
+  makeStyles: PropTypes.func
+}, _StudentAnalysisReportCardPresenter.defaultProps = {
+  studentAnalyses: void 0,
+  analysisError: void 0,
+  generationInProgress: void 0
+}, _StudentAnalysisReportCardPresenter)) || _class);

package/es/reporting/components/resources/StudentAnalysis/ReportCard/styles.js

@@ -0,0 +1,41 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+export var generateStyle = function generateStyle(componentTheme, props) {
+  var msMaxWidth = 'max-width: 25rem';
+  var mq = "@media only screen and (".concat(msMaxWidth, ")");
+  return {
+    reportCard: _objectSpread(_defineProperty({
+      width: componentTheme.cardWidth,
+      padding: componentTheme.cardPadding,
+      margin: componentTheme.cardMargin,
+      display: 'inline-flex',
+      flexDirection: 'column'
+    }, mq, {
+      width: 'initial',
+      maxWidth: componentTheme.cardWidth
+    }), !props.studentAnalyses && !props.analysisError && _defineProperty({
+      height: componentTheme.cardHeight
+    }, mq, {
+      height: 'initial'
+    })),
+    studentAnalysesSummary: {
+      borderBottom: "1px solid ".concat(componentTheme.quizSummaryBorderBottomColor),
+      paddingBottom: '15px',
+      marginBottom: '15px'
+    },
+    emptyCardBodyContainer: {
+      display: 'flex',
+      justifyContent: 'flex-end',
+      alignItems: 'flex-end',
+      alignSelf: 'flex-end',
+      height: '100%'
+    },
+    dateContainer: {
+      maxWidth: '160px',
+      paddingRight: '10px'
+    },
+    titleContainer: {
+      paddingBottom: '15px'
+    }
+  };
+};

package/es/reporting/components/resources/StudentAnalysis/ReportCard/theme.js

@@ -0,0 +1,12 @@
+export var generateComponentTheme = function generateComponentTheme(_ref) {
+  var spacing = _ref.spacing,
+    colors = _ref.colors;
+  return {
+    metricsPadding: spacing.medium,
+    cardHeight: '6rem',
+    cardWidth: '19.5rem',
+    cardPadding: spacing.medium,
+    cardMargin: spacing.xSmall,
+    quizSummaryBorderBottomColor: colors.tiara
+  };
+};

package/es/reporting/components/resources/StudentAnalysis/fetchReport.js

@@ -0,0 +1,48 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { getFailedToFetchReports, getLastReportGenerationFailed } from "../common/errorMessages.js";
+export var fetchReport = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref) {
+    var activeQuizId, setFetchInProgress, setStudentAnalyses, setStatusPollingInProgress, setAnalysisError, setGenerationInProgress, addError, fetchStudentAnalyses, setAnalysisFetchError, getErrorMessageForCode, studentAnalyses, isAnalysisInProgress, isAnalysisFailed, analysisErrorCode;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            activeQuizId = _ref.activeQuizId, setFetchInProgress = _ref.setFetchInProgress, setStudentAnalyses = _ref.setStudentAnalyses, setStatusPollingInProgress = _ref.setStatusPollingInProgress, setAnalysisError = _ref.setAnalysisError, setGenerationInProgress = _ref.setGenerationInProgress, addError = _ref.addError, fetchStudentAnalyses = _ref.fetchStudentAnalyses, setAnalysisFetchError = _ref.setAnalysisFetchError, getErrorMessageForCode = _ref.getErrorMessageForCode;
+            _context.prev = 1;
+            setAnalysisFetchError(false);
+            setFetchInProgress(true);
+            _context.next = 6;
+            return fetchStudentAnalyses(activeQuizId);
+          case 6:
+            studentAnalyses = _context.sent;
+            isAnalysisInProgress = studentAnalyses.new_analysis_in_progress;
+            isAnalysisFailed = studentAnalyses.last_analysis_failed;
+            analysisErrorCode = studentAnalyses.last_analysis_failed_error_code;
+            setGenerationInProgress(isAnalysisInProgress);
+            setStatusPollingInProgress(isAnalysisInProgress);
+            setStudentAnalyses(studentAnalyses.last_successful_analysis);
+            setAnalysisError(isAnalysisFailed ? getErrorMessageForCode(analysisErrorCode, getLastReportGenerationFailed()) : null);
+            _context.next = 21;
+            break;
+          case 16:
+            _context.prev = 16;
+            _context.t0 = _context["catch"](1);
+            setStudentAnalyses(null);
+            setAnalysisFetchError(true);
+            addError(getFailedToFetchReports());
+          case 21:
+            _context.prev = 21;
+            setFetchInProgress(false);
+            return _context.finish(21);
+          case 24:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[1, 16, 21, 24]]);
+  }));
+  return function fetchReport(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();

package/es/reporting/components/resources/StudentAnalysis/fetchReportStatus.js

@@ -0,0 +1,42 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { getFailedToFetchReports } from "../common/errorMessages.js";
+import { STUDENT_ANALYSES } from '@instructure/quiz-common';
+export var fetchReportStatus = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref) {
+    var activeQuizId, addError, fetchAnalysesStatus, instrumentedFetchReports, setStatusPollingInProgress, setGenerationInProgress, status, isReportGenerationReady;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            activeQuizId = _ref.activeQuizId, addError = _ref.addError, fetchAnalysesStatus = _ref.fetchAnalysesStatus, instrumentedFetchReports = _ref.instrumentedFetchReports, setStatusPollingInProgress = _ref.setStatusPollingInProgress, setGenerationInProgress = _ref.setGenerationInProgress;
+            _context.prev = 1;
+            _context.next = 4;
+            return fetchAnalysesStatus(activeQuizId, 'last_attempt', STUDENT_ANALYSES);
+          case 4:
+            status = _context.sent;
+            isReportGenerationReady = !status.student_analyses_in_progress;
+            if (isReportGenerationReady) {
+              instrumentedFetchReports();
+              setStatusPollingInProgress(false);
+              setGenerationInProgress(false);
+            }
+            return _context.abrupt("return", isReportGenerationReady);
+          case 10:
+            _context.prev = 10;
+            _context.t0 = _context["catch"](1);
+            addError(getFailedToFetchReports());
+            setStatusPollingInProgress(false);
+            setGenerationInProgress(false);
+            return _context.abrupt("return", true);
+          case 16:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[1, 10]]);
+  }));
+  return function fetchReportStatus(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();

package/es/reporting/components/resources/StudentAnalysis/withStudentAnalysisReportState.js

@@ -0,0 +1,39 @@
+import { connect } from "../../../../common/react-redux.js";
+import { featureOn } from "../../../../common/util/featureCheck.js";
+import { withStudentAnalysisReportStatePresenter } from "./withStudentAnalysisReportStatePresenter.js";
+import { bindActionCreators, compose } from 'redux';
+import { getStudentAnalyses, getStudentAnalysisFetchInProgress, getStudentAnalysisGenerationInProgress, getAnalysisError, getStudentAnalysisStatusPollingInProgress } from "../../../../common/selectors/analyses.js";
+import { setStudentAnalyses, setStudentAnalysisFetchInProgress, setStudentAnalysesGenerationInProgress, setAnalysisError, setStudentAnalysisStatusPollingInProgress } from "../../../../common/actions/analyses.js";
+import { getAnalysesStatus as fetchAnalysesStatus } from "../../../api/getAnalysesStatus.js";
+import { fetchStudentAnalyses } from "../../../api/fetchStudentAnalyses.js";
+import { addError } from "../../../../common/actions/alerts.js";
+import { getActiveQuizId } from "../../../../common/selectors/quizzes.js";
+import { getAnalysesExport } from "../../../api/getAnalysesExport.js";
+var DEFAULT_POLLING_INTERVAL = 3000;
+var mapStateToProps = function mapStateToProps(state, ownProps) {
+  return {
+    studentAnalyses: getStudentAnalyses(state),
+    fetchInProgress: getStudentAnalysisFetchInProgress(state),
+    generationInProgress: getStudentAnalysisGenerationInProgress(state),
+    statusPollingInProgress: getStudentAnalysisStatusPollingInProgress(state),
+    analysisError: getAnalysisError(state),
+    activeQuizId: ownProps.activeQuizId || getActiveQuizId(state),
+    getAnalysesExport: getAnalysesExport,
+    fetchStudentAnalyses: fetchStudentAnalyses,
+    fetchAnalysesStatus: fetchAnalysesStatus,
+    pollingInterval: ownProps.pollingInterval || DEFAULT_POLLING_INTERVAL,
+    exportEnabled: featureOn('student_analysis_csv')
+  };
+};
+var mapDispatchToProps = function mapDispatchToProps(dispatch, ownProps) {
+  return {
+    setStudentAnalyses: bindActionCreators(setStudentAnalyses, dispatch),
+    setFetchInProgress: bindActionCreators(setStudentAnalysisFetchInProgress, dispatch),
+    setGenerationInProgress: bindActionCreators(setStudentAnalysesGenerationInProgress, dispatch),
+    setAnalysisError: bindActionCreators(setAnalysisError, dispatch),
+    addError: ownProps.addError || bindActionCreators(addError, dispatch),
+    setStatusPollingInProgress: bindActionCreators(setStudentAnalysisStatusPollingInProgress, dispatch)
+  };
+};
+var withStudentAnalysisReportState = compose(connect(mapStateToProps, mapDispatchToProps), withStudentAnalysisReportStatePresenter);
+export default withStudentAnalysisReportState;

package/es/reporting/components/resources/StudentAnalysis/withStudentAnalysisReportStatePresenter.js

@@ -0,0 +1,222 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import React, { useEffect, useState } from 'react';
+import PropTypes from 'prop-types';
+import { generateReports as triggerReportGeneration } from "../common/generateReports.js";
+import { exportReports as triggerReportExport } from "../common/exportReports.js";
+import { getErrorMessageForCode } from "../common/errorCodes.js";
+import { saveFile } from "../common/utils.js";
+import { fetchReport } from "./fetchReport.js";
+import { fetchReportStatus } from "./fetchReportStatus.js";
+import { STUDENT_ANALYSES } from '@instructure/quiz-common';
+import { studentAnalysesPropType } from "../common/propTypes.js";
+export var withStudentAnalysisReportStatePresenter = function withStudentAnalysisReportStatePresenter(OriginalComponent) {
+  var StudentAnalysisReportStatePresenter = function StudentAnalysisReportStatePresenter(_ref) {
+    var studentAnalyses = _ref.studentAnalyses,
+      fetchInProgress = _ref.fetchInProgress,
+      generationInProgress = _ref.generationInProgress,
+      analysisError = _ref.analysisError,
+      setStudentAnalyses = _ref.setStudentAnalyses,
+      addError = _ref.addError,
+      setFetchInProgress = _ref.setFetchInProgress,
+      setGenerationInProgress = _ref.setGenerationInProgress,
+      setAnalysisError = _ref.setAnalysisError,
+      activeQuizId = _ref.activeQuizId,
+      generateAnalysis = _ref.generateAnalysis,
+      fetchStudentAnalyses = _ref.fetchStudentAnalyses,
+      getAnalysesExport = _ref.getAnalysesExport,
+      fetchAnalysesStatus = _ref.fetchAnalysesStatus,
+      statusPollingInProgress = _ref.statusPollingInProgress,
+      setStatusPollingInProgress = _ref.setStatusPollingInProgress,
+      pollingInterval = _ref.pollingInterval,
+      disableReportsCache = _ref.disableReportsCache,
+      passThroughProps = _objectWithoutProperties(_ref, ["studentAnalyses", "fetchInProgress", "generationInProgress", "analysisError", "setStudentAnalyses", "addError", "setFetchInProgress", "setGenerationInProgress", "setAnalysisError", "activeQuizId", "generateAnalysis", "fetchStudentAnalyses", "getAnalysesExport", "fetchAnalysesStatus", "statusPollingInProgress", "setStatusPollingInProgress", "pollingInterval", "disableReportsCache"]);
+    StudentAnalysisReportStatePresenter.displayName = "StudentAnalysisReportStatePresenter(".concat(OriginalComponent.displayName || OriginalComponent.name, ")");
+    var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      analysisFetchError = _useState2[0],
+      setAnalysisFetchError = _useState2[1];
+    var instrumentedFetchReports = function instrumentedFetchReports() {
+      return fetchReport({
+        activeQuizId: activeQuizId,
+        addError: addError,
+        fetchStudentAnalyses: fetchStudentAnalyses,
+        setAnalysisError: setAnalysisError,
+        setStatusPollingInProgress: setStatusPollingInProgress,
+        setGenerationInProgress: setGenerationInProgress,
+        setFetchInProgress: setFetchInProgress,
+        setStudentAnalyses: setStudentAnalyses,
+        getErrorMessageForCode: getErrorMessageForCode,
+        setAnalysisFetchError: setAnalysisFetchError
+      });
+    };
+    var instrumentedStatusFetching = function instrumentedStatusFetching() {
+      return fetchReportStatus({
+        activeQuizId: activeQuizId,
+        addError: addError,
+        setGenerationInProgress: setGenerationInProgress,
+        setStatusPollingInProgress: setStatusPollingInProgress,
+        fetchAnalysesStatus: fetchAnalysesStatus,
+        instrumentedFetchReports: instrumentedFetchReports
+      });
+    };
+    function generateReport() {
+      return _generateReport.apply(this, arguments);
+    }
+    function _generateReport() {
+      _generateReport = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+        var filter,
+          analysisType,
+          generationConfig,
+          _args3 = arguments;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                filter = _args3.length > 0 && _args3[0] !== void 0 ? _args3[0] : 'last_attempt';
+                analysisType = _args3.length > 1 ? _args3[1] : void 0;
+                generationConfig = {
+                  filter: filter,
+                  analysisType: analysisType,
+                  setGenerationInProgress: setGenerationInProgress,
+                  setStatusPollingInProgress: setStatusPollingInProgress,
+                  generateAnalysis: generateAnalysis,
+                  addError: addError
+                };
+                _context3.next = 5;
+                return triggerReportGeneration(generationConfig);
+              case 5:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3);
+      }));
+      return _generateReport.apply(this, arguments);
+    }
+    function exportReport(_x) {
+      return _exportReport.apply(this, arguments);
+    }
+    function _exportReport() {
+      _exportReport = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4(format) {
+        var filter,
+          analysisType,
+          exportConfig,
+          _args4 = arguments;
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                filter = _args4.length > 1 && _args4[1] !== void 0 ? _args4[1] : 'last_attempt';
+                analysisType = _args4.length > 2 && _args4[2] !== void 0 ? _args4[2] : STUDENT_ANALYSES;
+                exportConfig = {
+                  getAnalysesExport: getAnalysesExport,
+                  format: format,
+                  filter: filter,
+                  activeQuizId: activeQuizId,
+                  addError: addError,
+                  saveFile: saveFile,
+                  analysisType: analysisType
+                };
+                _context4.next = 5;
+                return triggerReportExport(exportConfig);
+              case 5:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4);
+      }));
+      return _exportReport.apply(this, arguments);
+    }
+    useEffect(function () {
+      var fetchIfNeeded = /*#__PURE__*/function () {
+        var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+          return _regeneratorRuntime.wrap(function _callee$(_context) {
+            while (1) {
+              switch (_context.prev = _context.next) {
+                case 0:
+                  if (!(!studentAnalyses || disableReportsCache)) {
+                    _context.next = 3;
+                    break;
+                  }
+                  _context.next = 3;
+                  return instrumentedFetchReports();
+                case 3:
+                case "end":
+                  return _context.stop();
+              }
+            }
+          }, _callee);
+        }));
+        return function fetchIfNeeded() {
+          return _ref2.apply(this, arguments);
+        };
+      }();
+      fetchIfNeeded();
+    }, []);
+    var recursiveInstrumentedStatusFetching = /*#__PURE__*/function () {
+      var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+        var isReportGenerationReady;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                _context2.next = 2;
+                return instrumentedStatusFetching();
+              case 2:
+                isReportGenerationReady = _context2.sent;
+                !isReportGenerationReady && setTimeout(recursiveInstrumentedStatusFetching, pollingInterval);
+              case 4:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }));
+      return function recursiveInstrumentedStatusFetching() {
+        return _ref3.apply(this, arguments);
+      };
+    }();
+    useEffect(function () {
+      statusPollingInProgress && recursiveInstrumentedStatusFetching();
+    }, [statusPollingInProgress]);
+    return /*#__PURE__*/React.createElement(OriginalComponent, Object.assign({
+      studentAnalyses: studentAnalyses,
+      fetchInProgress: fetchInProgress,
+      generationInProgress: generationInProgress,
+      analysisError: analysisError,
+      exportReport: exportReport,
+      generateReport: generateReport,
+      analysisFetchError: analysisFetchError
+    }, passThroughProps));
+  };
+  StudentAnalysisReportStatePresenter.propTypes = {
+    studentAnalyses: studentAnalysesPropType,
+    fetchInProgress: PropTypes.bool.isRequired,
+    generationInProgress: PropTypes.bool.isRequired,
+    statusPollingInProgress: PropTypes.bool.isRequired,
+    analysisError: PropTypes.string,
+    setStudentAnalyses: PropTypes.func.isRequired,
+    setFetchInProgress: PropTypes.func.isRequired,
+    setGenerationInProgress: PropTypes.func.isRequired,
+    setAnalysisError: PropTypes.func.isRequired,
+    setStatusPollingInProgress: PropTypes.func.isRequired,
+    activeQuizId: PropTypes.string.isRequired,
+    fetchStudentAnalyses: PropTypes.func.isRequired,
+    fetchAnalysesStatus: PropTypes.func.isRequired,
+    getAnalysesExport: PropTypes.func.isRequired,
+    addError: PropTypes.func.isRequired,
+    pollingInterval: PropTypes.number.isRequired,
+    generateAnalysis: PropTypes.func.isRequired,
+    disableReportsCache: PropTypes.bool
+  };
+  StudentAnalysisReportStatePresenter.defaultProps = {
+    studentAnalyses: void 0,
+    analysisError: '',
+    disableReportsCache: false
+  };
+  return StudentAnalysisReportStatePresenter;
+};

package/es/reporting/components/resources/common/ExportButton/index.js

@@ -0,0 +1,24 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import t from '@instructure/quiz-i18n/es/format-message';
+import { Text } from '@instructure/ui-text';
+import { Button } from '@instructure/ui-buttons';
+export var ExportButton = function ExportButton(_ref) {
+  var enabled = _ref.enabled,
+    handleExport = _ref.handleExport;
+  return /*#__PURE__*/React.createElement(Button, {
+    color: enabled ? 'secondary' : 'primary-inverse',
+    interaction: enabled ? 'enabled' : 'disabled',
+    onClick: handleExport,
+    themeOverride: {
+      lineHeight: '24px'
+    },
+    "data-automation": "sdk-new-report-export-button"
+  }, /*#__PURE__*/React.createElement(Text, {
+    size: "medium"
+  }, t('Export CSV')));
+};
+ExportButton.propTypes = {
+  enabled: PropTypes.bool.isRequired,
+  handleExport: PropTypes.func.isRequired
+};

package/es/reporting/components/resources/{NewQuizAndItemAnalysis → common}/errorCodes.js

@@ -1,4 +1,4 @@
-import { getReportGenerationFailure, getInsufficentSubmissionNumberError, getOngoingReportGenerationError, getMinimumThreeGradedSubmissionError, getNotEnoughDataAvailableError } from "./errorMessages.js";
+import { getReportGenerationFailure, getInsufficientSubmissionNumberError, getOngoingReportGenerationError, getMinimumThreeGradedSubmissionError, getNotEnoughDataAvailableError } from "./errorMessages.js";
 import { DEFAULT_ALERT_TIME } from '@instructure/quiz-common';
 export var INSUFFICIENT_NUMBER_OF_SESSIONS = 'INSUFFICIENT_NUMBER_OF_SESSIONS';
 export var ANALYSIS_GENERATION_IN_PROGRESS = 'ANALYSIS_GENERATION_IN_PROGRESS';
@@ -9,7 +9,7 @@ export var getErrorMessageForCode = function getErrorMessageForCode(code) {
   var defaultMsg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
   switch (code) {
     case INSUFFICIENT_NUMBER_OF_SESSIONS:
-      return getInsufficentSubmissionNumberError();
+      return getInsufficientSubmissionNumberError();
     case ANALYSIS_GENERATION_IN_PROGRESS:
       return getOngoingReportGenerationError();
     case GENERAL_ANALYSIS_ERROR:

package/es/reporting/components/resources/{NewQuizAndItemAnalysis → common}/errorMessages.js

@@ -11,7 +11,7 @@ export var getLastReportGenerationFailed = function getLastReportGenerationFaile
 export var getReportGenerationFailure = function getReportGenerationFailure() {
   return t('An error has occurred while generating this report. Please try again.');
 };
-export var getInsufficentSubmissionNumberError = function getInsufficentSubmissionNumberError() {
+export var getInsufficientSubmissionNumberError = function getInsufficientSubmissionNumberError() {
   return t('There is not enough data available to generate this report. A minimum of 3 submissions is required to generate. Please try again when more submissions are available.');
 };
 export var getOngoingReportGenerationError = function getOngoingReportGenerationError() {

package/es/reporting/components/resources/{NewQuizAndItemAnalysis → common}/exportReports.js

@@ -2,17 +2,18 @@ import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { getFailedToExportReports } from "./errorMessages.js";
 import contentDisposition from 'content-disposition';
+import { ITEM_ANALYSES } from '@instructure/quiz-common';
 export var exportReports = /*#__PURE__*/function () {
   var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref) {
-    var getAnalysesExport, activeQuizId, filter, format, saveFile, addError, response, dispositionHeader, disposition, filename, blob;
+    var getAnalysesExport, activeQuizId, filter, format, saveFile, addError, _ref$analysisType, analysisType, response, dispositionHeader, disposition, filename, blob;
     return _regeneratorRuntime.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            getAnalysesExport = _ref.getAnalysesExport, activeQuizId = _ref.activeQuizId, filter = _ref.filter, format = _ref.format, saveFile = _ref.saveFile, addError = _ref.addError;
+            getAnalysesExport = _ref.getAnalysesExport, activeQuizId = _ref.activeQuizId, filter = _ref.filter, format = _ref.format, saveFile = _ref.saveFile, addError = _ref.addError, _ref$analysisType = _ref.analysisType, analysisType = _ref$analysisType === void 0 ? ITEM_ANALYSES : _ref$analysisType;
             _context.prev = 1;
             _context.next = 4;
-            return getAnalysesExport(activeQuizId, format, filter);
+            return getAnalysesExport(activeQuizId, format, filter, analysisType);
           case 4:
             response = _context.sent;
             dispositionHeader = response.headers.get('Content-Disposition');

package/es/reporting/components/resources/{NewQuizAndItemAnalysis → common}/propTypes.js

@@ -26,6 +26,9 @@ export var quizAnalysisPropType = PropTypes.shape({
     average_attempts: PropTypes.number
   }).isRequired
 });
+export var studentAnalysesPropType = PropTypes.shape({
+  created_timestamp: PropTypes.string.isRequired
+});
 export var aggregateDetailPropType = PropTypes.shape({
   count: PropTypes.number.isRequired,
   percentage: PropTypes.number.isRequired