@instructure/outcomes-ui 2.1.2 → 2.1.3

package/es/translated/vi/store/report/actions.js

@@ -0,0 +1,144 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { createAction } from 'redux-actions';
+import { CALL_SERVICE } from '@instructure/redux-service-middleware';
+import { getUsers, getPageLoading } from "./selectors.js";
+import { SET_REPORT_PAGE, SET_REPORT_PAGE_DATA, SET_REPORT_OUTCOMES, SET_REPORT_ROLLUPS, SET_REPORT_RESULTS, SET_REPORT_USERS, VIEW_REPORT_ALIGNMENT, CLOSE_REPORT_ALIGNMENT, SET_REPORT_LOADING } from "../../constants.js";
+import { getConfig } from "../config/selectors.js";
+import { setError } from "../context/actions.js";
+/*
+ * action creators
+ */
+
+export var setReportOutcomes = createAction(SET_REPORT_OUTCOMES);
+export var setRollups = createAction(SET_REPORT_ROLLUPS);
+export var setResults = createAction(SET_REPORT_RESULTS);
+export var viewReportAlignment = createAction(VIEW_REPORT_ALIGNMENT);
+export var closeReportAlignment = createAction(CLOSE_REPORT_ALIGNMENT);
+export var setUsers = createAction(SET_REPORT_USERS);
+export var setPageData = createAction(SET_REPORT_PAGE_DATA);
+export var setPage = createAction(SET_REPORT_PAGE);
+export var setLoading = createAction(SET_REPORT_LOADING);
+export var loadUsers = function loadUsers(artifactType, artifactId, pageNumber) {
+  return function (dispatch, getState, _arg, scope) {
+    var _getConfig = getConfig(getState(), scope),
+        host = _getConfig.host,
+        jwt = _getConfig.jwt;
+
+    return dispatch({
+      type: CALL_SERVICE,
+      payload: {
+        service: 'outcomes',
+        method: 'getUsers',
+        args: [host, jwt, artifactType, artifactId, pageNumber]
+      }
+    });
+  };
+};
+export var loadPage = function loadPage(artifactType, artifactId, pageNumber, loadUsersOverride) {
+  return function (dispatch, getState, _arg, scope) {
+    var loading = getPageLoading(getState(), scope);
+
+    if (!loading) {
+      dispatch(setLoading(true));
+      dispatch(setPage({
+        number: pageNumber,
+        loading: true
+      }));
+      var usersPromiseChain;
+
+      if (loadUsersOverride) {
+        // if the override function is provided, we assume the upstream application has handled dispatching and is
+        // returning a promise to us
+        usersPromiseChain = loadUsersOverride(artifactType, artifactId, pageNumber);
+      } else {
+        usersPromiseChain = dispatch(loadUsers(artifactType, artifactId, pageNumber));
+      }
+
+      return usersPromiseChain.then(function (_ref) {
+        var users = _ref.users,
+            perPage = _ref.perPage,
+            total = _ref.total;
+        var pageData = {
+          perPage: perPage,
+          total: total
+        };
+        dispatch(setUsers(users));
+        return dispatch(setPageData(pageData));
+      }).then(function () {
+        return dispatch(loadRollups(artifactType, artifactId));
+      }).then(function () {
+        return dispatch(setPage({
+          number: pageNumber,
+          loading: false
+        }));
+      }).then(function () {
+        return dispatch(setLoading(false));
+      }).catch(function (e) {
+        return dispatch(setError(e));
+      });
+    } else {
+      return Promise.resolve();
+    }
+  };
+};
+export var loadRollups = function loadRollups(artifactType, artifactId) {
+  return function (dispatch, getState, _arg, scope) {
+    var _getConfig2 = getConfig(getState(), scope),
+        host = _getConfig2.host,
+        jwt = _getConfig2.jwt;
+
+    var userList = getUsers(getState(), scope).map(function (user) {
+      return user.uuid;
+    });
+    var jsonPromise = dispatch({
+      type: CALL_SERVICE,
+      payload: {
+        service: 'outcomes',
+        method: 'getOutcomeRollups',
+        args: [host, jwt, artifactType, artifactId]
+      }
+    });
+    return jsonPromise.then(function (json) {
+      var outcomes = json.reduce(function (acc, el) {
+        return Object.assign(acc, _defineProperty({}, el.outcome.id, el.outcome));
+      }, {});
+      var rollups = json.map(function (el) {
+        return {
+          outcomeId: el.outcome.id,
+          averageScore: el.average_score,
+          count: el.count,
+          masteryCount: el.mastery_count,
+          childArtifactCount: el.child_artifact_count,
+          usesBank: el.uses_bank
+        };
+      });
+      dispatch(setReportOutcomes(outcomes));
+      dispatch(setRollups(rollups));
+
+      var getOutcomeResults = function getOutcomeResults(outcomeId) {
+        return dispatch({
+          type: CALL_SERVICE,
+          payload: {
+            service: 'outcomes',
+            method: 'getOutcomeResults',
+            args: [host, jwt, artifactType, artifactId, outcomeId, userList]
+          }
+        });
+      };
+
+      var resultPromises = json.map(function (el) {
+        return getOutcomeResults(el.outcome.id) // eslint-disable-line promise/no-nesting
+        .then(function (results) {
+          dispatch(setResults({
+            outcomeId: el.outcome.id,
+            results: results
+          }));
+          return results;
+        });
+      });
+      return Promise.all(resultPromises);
+    }).catch(function (e) {
+      return dispatch(setError(e));
+    });
+  };
+};

package/es/translated/vi/store/report/reducers.js

@@ -0,0 +1,62 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { List, Map, fromJS } from 'immutable';
+import { handleActions } from 'redux-actions';
+import { combineReducers } from 'redux-immutable';
+import { setPage, setPageData, setUsers, setReportOutcomes, setRollups, setResults, setLoading } from "./actions.js";
+var users = handleActions(_defineProperty({}, setUsers, function (state, action) {
+  return fromJS(action.payload);
+}), List());
+var page = handleActions(_defineProperty({}, setPage, function (state, action) {
+  return fromJS(action.payload);
+}), fromJS({
+  number: void 0
+}));
+var pageData = handleActions(_defineProperty({}, setPageData, function (state, action) {
+  return fromJS(action.payload);
+}), Map());
+var outcomes = handleActions(_defineProperty({}, setReportOutcomes, function (state, action) {
+  return fromJS(action.payload);
+}), Map());
+var rollups = handleActions(_defineProperty({}, setRollups, function (state, action) {
+  return fromJS(action.payload);
+}), List());
+var loading = handleActions(_defineProperty({}, setLoading, function (state, action) {
+  return fromJS(action.payload);
+}), false);
+var results = handleActions(_defineProperty({}, setResults, function (state, action) {
+  var _action$payload = action.payload,
+      outcomeId = _action$payload.outcomeId,
+      results = _action$payload.results;
+  var resultMap = results.map(function (_ref) {
+    var userId = _ref.user_uuid,
+        percentScore = _ref.percent_score,
+        points = _ref.points,
+        pointsPossible = _ref.points_possible;
+    var ungulated = fromJS({
+      userId: userId,
+      percentScore: percentScore,
+      points: points,
+      pointsPossible: pointsPossible
+    });
+    return [userId.toString(), ungulated];
+  });
+  return state.set(outcomeId, Map(resultMap));
+}), Map());
+var openReportAlignmentId = handleActions({
+  VIEW_REPORT_ALIGNMENT: function VIEW_REPORT_ALIGNMENT(state, action) {
+    return action.payload;
+  },
+  CLOSE_REPORT_ALIGNMENT: function CLOSE_REPORT_ALIGNMENT() {
+    return null;
+  }
+}, null);
+export default combineReducers({
+  page: page,
+  pageData: pageData,
+  users: users,
+  outcomes: outcomes,
+  results: results,
+  rollups: rollups,
+  openReportAlignmentId: openReportAlignmentId,
+  loading: loading
+});

package/es/translated/vi/store/report/selectors.js

@@ -0,0 +1,52 @@
+import { Map } from 'immutable';
+
+function restrict(state, scope) {
+  return state.getIn([scope, 'report']) || Map();
+}
+
+export function getPageCount(state, scope) {
+  if (state) {
+    var pageData = restrict(state, scope).get('pageData');
+
+    if (pageData) {
+      var _pageData$toJS = pageData.toJS(),
+          total = _pageData$toJS.total,
+          perPage = _pageData$toJS.perPage;
+
+      return Math.ceil(total / perPage);
+    }
+  }
+
+  return null;
+}
+export function getLoading(state, scope) {
+  return state && restrict(state, scope).get('loading');
+}
+export function getPageNumber(state, scope) {
+  return state && restrict(state, scope).getIn(['page', 'number']);
+}
+export function getPageLoading(state, scope) {
+  return state && restrict(state, scope).getIn(['page', 'loading'], false);
+}
+export function getUsers(state, scope) {
+  var users = state && restrict(state, scope).get('users');
+  return users ? users.toJS() : [];
+}
+export function getRollups(state, scope) {
+  var rollups = state && restrict(state, scope).get('rollups');
+  return rollups ? rollups.toJS() : [];
+}
+export function getScore(state, scope, outcomeId, userId) {
+  var score = state && restrict(state, scope).getIn(['results', outcomeId, userId]);
+  return score ? score.toJS() : null;
+}
+export function isOpen(state, scope, outcomeId) {
+  return restrict(state, scope).get('openReportAlignmentId') === outcomeId;
+}
+export function getReportOutcome(state, scope, outcomeId) {
+  var outcome = restrict(state, scope).getIn(['outcomes', outcomeId]);
+  return outcome ? outcome.toJS() : null;
+}
+export function hasAnyOutcomes(state, scope) {
+  return state && restrict(state, scope).getIn(['outcomes']).size > 0;
+}

package/es/translated/vi/store/search/__tests__/actions.test.js

@@ -0,0 +1,149 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { expect } from 'chai';
+import sinon from 'sinon';
+import { fromJS } from 'immutable';
+import { SET_SEARCH_TEXT, SET_SEARCH_LOADING, SET_SEARCH_ENTRIES } from "../../../constants.js";
+import createMockStore, { scopeActions } from "../../../test/createMockStore.js";
+import * as actions from "../actions.js";
+import { setOutcomes } from "../../../store/context/actions.js";
+var scopedActions = scopeActions(_objectSpread(_objectSpread({}, actions), {}, {
+  setOutcomes: setOutcomes
+}));
+describe('search/actions', function () {
+  var state = fromJS({
+    scopeForTest: {
+      config: {
+        contextUuid: 'course_100'
+      },
+      OutcomePicker: {
+        search: {
+          searchText: 'abc',
+          pagination: {
+            page: 1,
+            total: null
+          },
+          isLoading: true,
+          entries: []
+        }
+      }
+    }
+  });
+  describe('search updates', function () {
+    var clock;
+    var service = {
+      getSearchResults: sinon.stub().returns(Promise.resolve({}))
+    };
+    beforeEach(function () {
+      clock = sinon.useFakeTimers();
+    });
+    afterEach(function () {
+      clock.restore();
+      service.getSearchResults.resetHistory();
+    });
+    describe('updateSearchText', function () {
+      it('handles search flow in the correct order', function () {
+        var store = createMockStore(state, service);
+        store.dispatch(actions.updateSearchText('def'));
+        expect(store.getActions()[0]).to.deep.equal(scopedActions.setSearchText('def'));
+        expect(store.getActions()[1]).to.deep.equal(scopedActions.setSearchPage(1));
+        expect(store.getActions()[2]).to.deep.equal(scopedActions.setSearchTotal(null));
+        expect(store.getActions()[3]).to.deep.equal(scopedActions.setSearchLoading(true));
+        expect(store.getActions()).to.have.length(4);
+        clock.tick(250);
+        expect(store.getActions()).to.have.length(5);
+        expect(service.getSearchResults).to.have.been.called;
+        expect(service.getSearchResults.getCall(0).args).to.include('def'); // text
+
+        expect(service.getSearchResults.getCall(0).args).to.include(1); // page
+      });
+    });
+    describe('updateSearchPage', function () {
+      it('triggers a search action', function () {
+        var store = createMockStore(state, service);
+        store.dispatch(actions.updateSearchPage(10));
+        expect(store.getActions()[0]).to.deep.equal(scopedActions.setSearchLoading(true));
+        expect(store.getActions()[1]).to.deep.equal(scopedActions.setSearchPage(10));
+        expect(store.getActions()).to.have.length(2);
+        clock.tick(250);
+        expect(store.getActions()).to.have.length(3);
+        expect(service.getSearchResults).to.have.been.called;
+        expect(service.getSearchResults.getCall(0).args).to.include('abc'); // text
+
+        expect(service.getSearchResults.getCall(0).args).to.include(10); // page
+      });
+    });
+  });
+  describe('setSearchText', function () {
+    it('creates an action', function () {
+      var action = actions.setSearchText('elephant');
+      expect(action.type).to.equal(SET_SEARCH_TEXT);
+      expect(action.payload).to.equal('elephant');
+    });
+  });
+  describe('setSearchLoading', function () {
+    it('creates an action', function () {
+      var action = actions.setSearchLoading(true);
+      expect(action.type).to.equal(SET_SEARCH_LOADING);
+      expect(action.payload).to.equal(true);
+    });
+  });
+  describe('setSearchEntries', function () {
+    it('creates an action', function () {
+      var action = actions.setSearchEntries([1, 2, 3]);
+      expect(action.type).to.equal(SET_SEARCH_ENTRIES);
+      expect(action.payload).to.eql([1, 2, 3]);
+    });
+  });
+  describe('searchOutcomes', function () {
+    var matches = [{
+      id: '1'
+    }];
+    var outcomes = {
+      course_100: {
+        1: {
+          id: '1'
+        },
+        2: {
+          id: '2'
+        }
+      }
+    };
+    var response = {
+      matches: matches,
+      outcomes: outcomes['course_100'],
+      total: 101
+    };
+    var service = {
+      getSearchResults: function getSearchResults() {
+        return new Promise(function (resolve) {
+          return resolve(response);
+        });
+      }
+    };
+    it('handles search flow in the correct order', function () {
+      var store = createMockStore(state, service);
+      return store.dispatch(actions.searchOutcomes('abc')).then(function () {
+        expect(store.getActions()[1]).to.deep.equal(scopedActions.setOutcomes(outcomes));
+        expect(store.getActions()[2]).to.deep.equal(scopedActions.setSearchEntries(matches));
+        expect(store.getActions()[3]).to.deep.equal(scopedActions.setSearchTotal(101));
+        expect(store.getActions()[4]).to.deep.equal(scopedActions.setSearchLoading(false));
+      });
+    });
+    it('does not set search entries if search query does not match', function () {
+      var store = createMockStore(state, service);
+      return store.dispatch(actions.searchOutcomes({
+        text: 'something else'
+      })).then(function () {
+        expect(store.getActions().length).to.equal(1);
+      });
+    });
+    it('does not set search entries if search page does not match', function () {
+      var store = createMockStore(state, service);
+      return store.dispatch(actions.searchOutcomes({
+        page: 12
+      })).then(function () {
+        expect(store.getActions().length).to.equal(1);
+      });
+    });
+  });
+});

package/es/translated/vi/store/search/__tests__/reducers.test.js

@@ -0,0 +1,45 @@
+import { fromJS } from 'immutable';
+import { expect } from 'chai';
+import * as actions from "../actions.js";
+import reducer from "../reducers.js";
+describe('search/reducers', function () {
+  var state = fromJS({
+    searchText: 'lion',
+    isLoading: false,
+    entries: [],
+    pagination: {
+      page: 1,
+      total: 10
+    }
+  });
+  describe('searchText', function () {
+    it('is set by setSearchText', function () {
+      var next = reducer(state, actions.setSearchText('elephant'));
+      expect(next.get('searchText')).to.equal('elephant');
+    });
+  });
+  describe('isLoading', function () {
+    it('is set by setSearchLoading', function () {
+      var next = reducer(state, actions.setSearchLoading(true));
+      expect(next.get('isLoading')).to.equal(true);
+    });
+  });
+  describe('entries', function () {
+    it('is set by setSearchEntries', function () {
+      var next = reducer(state, actions.setSearchEntries([]));
+      expect(next.get('entries')).to.deep.equal(fromJS([]));
+    });
+  });
+  describe('page', function () {
+    it('is set by setSearchPage', function () {
+      var next = reducer(state, actions.setSearchPage(111));
+      expect(next.get('pagination').get('page')).to.equal(111);
+    });
+  });
+  describe('total', function () {
+    it('is set by setSearchTotal', function () {
+      var next = reducer(state, actions.setSearchTotal(9));
+      expect(next.get('pagination').get('total')).to.equal(9);
+    });
+  });
+});

package/es/translated/vi/store/search/__tests__/selectors.test.js

@@ -0,0 +1,46 @@
+import { expect } from 'chai';
+import { fromJS } from 'immutable';
+import { getSearchText, getIsSearchLoading, getSearchEntries, getSearchPage, getSearchTotal } from "../selectors.js";
+describe('search/selectors', function () {
+  var scope = 'scopeForTest';
+  var state = fromJS({
+    scopeForTest: {
+      OutcomePicker: {
+        search: {
+          searchText: 'abc',
+          isLoading: true,
+          entries: [],
+          pagination: {
+            page: 7,
+            total: 100
+          }
+        }
+      }
+    }
+  });
+  describe('getSearchText', function () {
+    it('returns the search text', function () {
+      expect(getSearchText(state, scope)).to.equal('abc');
+    });
+  });
+  describe('getIsSearchLoading', function () {
+    it('returns the loading state', function () {
+      expect(getIsSearchLoading(state, scope)).to.equal(true);
+    });
+  });
+  describe('getSearchEntries', function () {
+    it('returns the search entries', function () {
+      expect(getSearchEntries(state, scope)).to.deep.equal([]);
+    });
+  });
+  describe('getSearchPage', function () {
+    it('returns the current page', function () {
+      expect(getSearchPage(state, scope)).to.equal(7);
+    });
+  });
+  describe('getSearchTotal', function () {
+    it('returns the current total', function () {
+      expect(getSearchTotal(state, scope)).to.equal(100);
+    });
+  });
+});

package/es/translated/vi/store/search/actions.js

@@ -0,0 +1,86 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { createAction } from 'redux-actions';
+import { CALL_SERVICE } from '@instructure/redux-service-middleware';
+import { getConfig } from "../config/selectors.js";
+import { getSearchText, getSearchPage } from "./selectors.js";
+import { SET_SEARCH_TEXT, SET_SEARCH_LOADING, SET_SEARCH_ENTRIES, SET_SEARCH_PAGE, SET_SEARCH_TOTAL } from "../../constants.js";
+import { setOutcomes } from "../context/actions.js";
+import debounceLatestPromise from "../../util/debouceLatestPromise.js";
+export var setSearchText = createAction(SET_SEARCH_TEXT);
+export var setSearchLoading = createAction(SET_SEARCH_LOADING);
+export var setSearchEntries = createAction(SET_SEARCH_ENTRIES);
+export var setSearchPage = createAction(SET_SEARCH_PAGE);
+export var setSearchTotal = createAction(SET_SEARCH_TOTAL);
+var getSearchResultsDebounced = debounceLatestPromise(function (dispatch) {
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+
+  return dispatch(searchOutcomes.apply(void 0, args));
+}, 250);
+
+var getSearchResultsAction = function getSearchResultsAction() {
+  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    args[_key2] = arguments[_key2];
+  }
+
+  return function (dispatch) {
+    return getSearchResultsDebounced.apply(void 0, [dispatch].concat(args));
+  };
+};
+
+export var searchOutcomes = function searchOutcomes(_ref) {
+  var text = _ref.text,
+      page = _ref.page;
+  return function (dispatch, getState, _arg, scope) {
+    var initialText = text || getSearchText(getState(), scope);
+    var initialPage = page || getSearchPage(getState(), scope);
+
+    var _getConfig = getConfig(getState(), scope),
+        host = _getConfig.host,
+        jwt = _getConfig.jwt,
+        contextUuid = _getConfig.contextUuid;
+
+    return dispatch({
+      type: CALL_SERVICE,
+      payload: {
+        service: 'outcomes',
+        method: 'getSearchResults',
+        args: [host, jwt, initialText, initialPage, contextUuid]
+      }
+    }).then(function (json) {
+      if (getSearchText(getState(), scope) === initialText && getSearchPage(getState(), scope) === initialPage) {
+        dispatch(setOutcomes(_defineProperty({}, contextUuid, json.outcomes)));
+        dispatch(setSearchEntries(json.matches));
+        dispatch(setSearchTotal(json.total));
+        dispatch(setSearchLoading(false));
+      }
+
+      return Promise.resolve();
+    });
+  };
+};
+export var updateSearchText = function updateSearchText(text) {
+  return function (dispatch, _getState, _arg, _scope) {
+    dispatch(setSearchText(text));
+    dispatch(setSearchPage(1));
+    dispatch(setSearchTotal(null));
+
+    if (text) {
+      dispatch(setSearchLoading(true));
+      dispatch(getSearchResultsAction({
+        text: text,
+        page: 1
+      }));
+    }
+  };
+};
+export var updateSearchPage = function updateSearchPage(page) {
+  return function (dispatch, _getState, _arg, _scope) {
+    dispatch(setSearchLoading(true));
+    dispatch(setSearchPage(page));
+    dispatch(getSearchResultsAction({
+      page: page
+    }));
+  };
+};

package/es/translated/vi/store/search/reducers.js

@@ -0,0 +1,21 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { handleActions } from 'redux-actions';
+import { combineReducers } from 'redux-immutable';
+import { List, fromJS } from 'immutable';
+import { setSearchText, setSearchLoading, setSearchEntries } from "./actions.js";
+import paginationReducer from "../utils/paginationReducer.js";
+var searchText = handleActions(_defineProperty({}, setSearchText, function (state, action) {
+  return action.payload;
+}), '');
+var isLoading = handleActions(_defineProperty({}, setSearchLoading, function (state, action) {
+  return action.payload;
+}), true);
+var entries = handleActions(_defineProperty({}, setSearchEntries, function (state, action) {
+  return fromJS(action.payload);
+}), List());
+export default combineReducers({
+  searchText: searchText,
+  isLoading: isLoading,
+  entries: entries,
+  pagination: paginationReducer('SEARCH')
+});

package/es/translated/vi/store/search/selectors.js

@@ -0,0 +1,42 @@
+import { Map } from 'immutable';
+import { createSelectorCreator, defaultMemoize } from 'reselect';
+import createCachedSelector from 're-reselect';
+import { isEqual } from 'lodash';
+import { getAnyOutcome } from "../alignments/selectors.js";
+var customDeepComparisonSelector = createSelectorCreator(defaultMemoize, isEqual);
+
+var getSearch = function getSearch(state, scope) {
+  return state.getIn([scope, 'OutcomePicker', 'search']) || Map();
+};
+
+export var getSearchEntries = createCachedSelector(function (state, scope) {
+  var entries = getSearch(state, scope).get('entries');
+  entries = entries ? entries.toJS() : [];
+  return entries.map(function (entry) {
+    return getAnyOutcome(state, scope, entry.id);
+  });
+}, function (entries) {
+  return entries;
+})(function (_state, scope) {
+  return scope;
+}, {
+  // Deep comparison: https://github.com/toomuchdesign/re-reselect/issues/31
+  selectorCreator: customDeepComparisonSelector
+});
+export var getSearchText = function getSearchText(state, scope) {
+  return getSearch(state, scope).get('searchText');
+};
+export var getIsSearchLoading = function getIsSearchLoading(state, scope) {
+  return getSearch(state, scope).get('isLoading');
+};
+
+var pagination = function pagination(state, scope) {
+  return getSearch(state, scope).get('pagination') || Map();
+};
+
+export var getSearchPage = function getSearchPage(state, scope) {
+  return pagination(state, scope).get('page');
+};
+export var getSearchTotal = function getSearchTotal(state, scope) {
+  return pagination(state, scope).get('total');
+};