@instructure/outcomes-ui 2.1.2 → 2.1.3

package/lib/translated/vi/store/alignments/__tests__/selectors.test.js

@@ -0,0 +1,134 @@
+"use strict";
+
+var _chai = require("chai");
+
+var _immutable = require("immutable");
+
+var _selectors = require("../selectors.js");
+
+describe('alignments/selectors', function () {
+  var state = (0, _immutable.fromJS)({
+    scopeForTest: {
+      alignments: {
+        alignedOutcomes: [{
+          id: '101',
+          label: 'l1',
+          title: 't2'
+        }, {
+          id: '102',
+          label: 'l2',
+          title: 't1'
+        }, {
+          id: '103',
+          label: 'l3',
+          title: 't3'
+        }],
+        openAlignmentId: 12
+      }
+    }
+  });
+  describe('getAlignedOutcomeIds', function () {
+    it('retrieves the correct value', function () {
+      (0, _chai.expect)((0, _selectors.getAlignedOutcomeIds)(state, 'scopeForTest')).to.deep.equal(['102', '101', '103']);
+    });
+    it('returns [] when not set', function () {
+      var newState = (0, _immutable.Map)();
+      (0, _chai.expect)((0, _selectors.getAlignedOutcomeIds)(newState, 'scopeForTest')).to.deep.equal([]);
+    });
+  });
+  describe('getAlignedOutcomes', function () {
+    it('retrieves the outcomes for each aligned outcome id', function () {
+      var outcomes = (0, _selectors.getAlignedOutcomes)(state, 'scopeForTest');
+      (0, _chai.expect)(outcomes).to.have.length(3);
+      (0, _chai.expect)(outcomes).to.deep.equal([{
+        id: '102',
+        label: 'l2',
+        title: 't1'
+      }, {
+        id: '101',
+        label: 'l1',
+        title: 't2'
+      }, {
+        id: '103',
+        label: 'l3',
+        title: 't3'
+      }]);
+    });
+    it('memoizes alignedOutcomes by scope', function () {
+      _selectors.getAlignedOutcomes.resetRecomputations();
+
+      _selectors.getAlignedOutcomes.clearCache();
+
+      (0, _selectors.getAlignedOutcomes)(state, 'scopeForTest');
+      (0, _selectors.getAlignedOutcomes)((0, _immutable.Map)(), 'newScope');
+      (0, _selectors.getAlignedOutcomes)(state, 'scopeForTest');
+      (0, _chai.expect)(_selectors.getAlignedOutcomes.recomputations()).to.equal(2);
+    });
+  });
+  describe('getAlignedOutcomeCount', function () {
+    it('returns the count when the list of outcomes is defined', function () {
+      var count = (0, _selectors.getAlignedOutcomeCount)(state, 'scopeForTest');
+      (0, _chai.expect)(count).to.equal(3);
+    });
+    it('returns 0 when the list is not defined', function () {
+      var count = (0, _selectors.getAlignedOutcomeCount)(state, 'anotherScope');
+      (0, _chai.expect)(count).to.equal(0);
+    });
+  });
+  describe('makeIsOpen', function () {
+    it('returns true if alignment id is openAlignmentId', function () {
+      (0, _chai.expect)((0, _selectors.makeIsOpen)(state, 'scopeForTest')(12)).to.be.true;
+    });
+    it('returns false if another alignment id is openAlignmentId', function () {
+      (0, _chai.expect)((0, _selectors.makeIsOpen)(state, 'scopeForTest')(13)).to.be.false;
+    });
+    it('returns false if no alignment is openAlignmentId', function () {
+      var newState = (0, _immutable.Map)();
+      (0, _chai.expect)((0, _selectors.makeIsOpen)(newState, 'scopeForTest')(12)).to.be.false;
+    });
+  });
+  describe('getAlignedOutcome', function () {
+    it('retrieves an aligned outcome by its id', function () {
+      var outcome = (0, _selectors.getAlignedOutcome)(state, 'scopeForTest', '101');
+      (0, _chai.expect)(outcome).to.deep.equal({
+        id: '101',
+        label: 'l1',
+        title: 't2'
+      });
+    });
+  });
+  describe('getAnyOutcome', function () {
+    it('can pull outcomes from aligned outcomes', function () {
+      var outcome = (0, _selectors.getAnyOutcome)(state, 'scopeForTest', '101');
+      (0, _chai.expect)(outcome.label).to.equal('l1');
+    });
+    it('can pull outcomes from context outcomes', function () {
+      var state = (0, _immutable.fromJS)({
+        scopeForTest: {
+          config: {
+            contextUuid: 'course_100'
+          }
+        },
+        context: {
+          outcomes: {
+            course_100: {
+              1: {
+                id: 1,
+                label: 'l1',
+                title: 't1',
+                child_ids: ['2', '3']
+              }
+            }
+          }
+        }
+      });
+      var outcome = (0, _selectors.getAnyOutcome)(state, 'scopeForTest', '1');
+      (0, _chai.expect)(outcome.label).to.equal('l1');
+    });
+    it('returns null if neither present', function () {
+      var state = (0, _immutable.Map)();
+      var outcome = (0, _selectors.getAnyOutcome)(state, 'scopeForTest', '101');
+      (0, _chai.expect)(outcome).to.be.null;
+    });
+  });
+});

package/lib/translated/vi/store/alignments/actions.js

@@ -0,0 +1,213 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.upsertArtifact = exports.loadArtifact = exports.clearAlignmentSet = exports.createAlignmentSet = exports.removeAlignment = exports.loadAlignments = exports.updateAlignments = exports.viewAlignment = exports.updateAlignment = exports.closeAlignment = exports.viewAlignmentAction = exports.setAlignments = void 0;
+
+var _reduxActions = require("redux-actions");
+
+var _reduxServiceMiddleware = require("@instructure/redux-service-middleware");
+
+var _constants = require("../../constants.js");
+
+var _selectors = require("./selectors.js");
+
+var _selectors2 = require("../config/selectors.js");
+
+var _actions = require("../context/actions.js");
+
+/*
+ * action creators
+ */
+var setAlignments = (0, _reduxActions.createAction)(_constants.SET_ALIGNMENTS);
+exports.setAlignments = setAlignments;
+var viewAlignmentAction = (0, _reduxActions.createAction)(_constants.VIEW_ALIGNMENT);
+exports.viewAlignmentAction = viewAlignmentAction;
+var closeAlignment = (0, _reduxActions.createAction)(_constants.CLOSE_ALIGNMENT);
+exports.closeAlignment = closeAlignment;
+var updateAlignment = (0, _reduxActions.createAction)(_constants.UPDATE_ALIGNMENT);
+exports.updateAlignment = updateAlignment;
+
+var viewAlignment = function viewAlignment(outcomeId) {
+  return function (dispatch, getState, _arg, scope) {
+    var outcome = (0, _selectors.getAlignedOutcome)(getState(), scope, outcomeId);
+    dispatch(viewAlignmentAction(outcomeId));
+
+    if (outcome && outcome.scoring_method) {
+      return Promise.resolve();
+    }
+
+    var _getConfig = (0, _selectors2.getConfig)(getState(), scope),
+        host = _getConfig.host,
+        jwt = _getConfig.jwt,
+        contextUuid = _getConfig.contextUuid;
+
+    return dispatch({
+      type: _reduxServiceMiddleware.CALL_SERVICE,
+      payload: {
+        service: 'outcomes',
+        method: 'getOutcome',
+        args: [host, jwt, outcomeId, contextUuid]
+      }
+    }).then(function (json) {
+      return dispatch(updateAlignment({
+        outcome: json
+      }));
+    });
+  };
+};
+
+exports.viewAlignment = viewAlignment;
+
+var updateAlignments = function updateAlignments(guid, outcomes, updateCallback) {
+  return function (dispatch) {
+    dispatch(setAlignments({
+      guid: guid,
+      outcomes: outcomes
+    }));
+
+    if (updateCallback) {
+      updateCallback({
+        guid: guid,
+        outcomes: outcomes
+      });
+    }
+
+    return Promise.resolve();
+  };
+};
+
+exports.updateAlignments = updateAlignments;
+
+var loadAlignments = function loadAlignments(alignmentSetId, updateCallback) {
+  return function (dispatch, getState, _arg, scope) {
+    if (alignmentSetId && (0, _selectors.getOutcomeAlignmentSetId)(getState(), scope) === alignmentSetId) {
+      return Promise.resolve();
+    }
+
+    var _getConfig2 = (0, _selectors2.getConfig)(getState(), scope),
+        host = _getConfig2.host,
+        jwt = _getConfig2.jwt,
+        contextUuid = _getConfig2.contextUuid;
+
+    return dispatch(clearAlignmentSet()).then(function () {
+      return dispatch({
+        type: _reduxServiceMiddleware.CALL_SERVICE,
+        payload: {
+          service: 'outcomes',
+          method: 'getAlignments',
+          args: [host, jwt, alignmentSetId, contextUuid]
+        }
+      });
+    }).then(function (json) {
+      return dispatch(updateAlignments(json.guid, json.outcomes, updateCallback));
+    }).catch(function (e) {
+      return dispatch((0, _actions.setError)(e));
+    });
+  };
+};
+
+exports.loadAlignments = loadAlignments;
+
+var removeAlignment = function removeAlignment(alignmentId, updateCallback) {
+  var shouldUpdateArtifact = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+  return function (dispatch, getState, _arg, scope) {
+    var newIds = (0, _selectors.getAlignedOutcomeIds)(getState(), scope).filter(function (id) {
+      return id !== alignmentId;
+    });
+
+    if (newIds.length === 0 && !shouldUpdateArtifact) {
+      return dispatch(clearAlignmentSet(updateCallback));
+    }
+
+    var updateAlignmentFunc = shouldUpdateArtifact ? upsertArtifact : createAlignmentSet;
+    return dispatch(updateAlignmentFunc(newIds)).then(function (response) {
+      var newOutcomes = newIds.map(function (id) {
+        return (0, _selectors.getAlignedOutcome)(getState(), scope, id);
+      });
+      dispatch(updateAlignments(response.guid, newOutcomes, updateCallback));
+    }).catch(function (e) {
+      return dispatch((0, _actions.setError)(e));
+    });
+  };
+};
+
+exports.removeAlignment = removeAlignment;
+
+var createAlignmentSet = function createAlignmentSet(outcomeIds) {
+  return function (dispatch, getState, _arg, scope) {
+    var _getConfig3 = (0, _selectors2.getConfig)(getState(), scope),
+        host = _getConfig3.host,
+        jwt = _getConfig3.jwt;
+
+    return dispatch({
+      type: _reduxServiceMiddleware.CALL_SERVICE,
+      payload: {
+        service: 'outcomes',
+        method: 'createAlignmentSet',
+        args: [host, jwt, outcomeIds]
+      }
+    });
+  };
+};
+
+exports.createAlignmentSet = createAlignmentSet;
+
+var clearAlignmentSet = function clearAlignmentSet(updateCallback) {
+  return function (dispatch) {
+    dispatch(updateAlignments(null, [], updateCallback));
+    return Promise.resolve();
+  };
+};
+
+exports.clearAlignmentSet = clearAlignmentSet;
+
+var loadArtifact = function loadArtifact() {
+  return function (dispatch, getState, _arg, scope) {
+    var _getConfig4 = (0, _selectors2.getConfig)(getState(), scope),
+        host = _getConfig4.host,
+        jwt = _getConfig4.jwt,
+        artifactType = _getConfig4.artifactType,
+        artifactId = _getConfig4.artifactId;
+
+    return dispatch(clearAlignmentSet()).then(function () {
+      return dispatch({
+        type: _reduxServiceMiddleware.CALL_SERVICE,
+        payload: {
+          service: 'outcomes',
+          method: 'getArtifact',
+          args: [host, jwt, artifactType, artifactId]
+        }
+      });
+    }).then(function (json) {
+      return dispatch(updateAlignments(json.guid, json.outcomes));
+    }).catch(function (e) {
+      return dispatch((0, _actions.setError)(e));
+    });
+  };
+};
+
+exports.loadArtifact = loadArtifact;
+
+var upsertArtifact = function upsertArtifact(outcomeIds) {
+  return function (dispatch, getState, _arg, scope) {
+    var _getConfig5 = (0, _selectors2.getConfig)(getState(), scope),
+        host = _getConfig5.host,
+        jwt = _getConfig5.jwt,
+        artifactType = _getConfig5.artifactType,
+        artifactId = _getConfig5.artifactId,
+        contextUuid = _getConfig5.contextUuid;
+
+    return dispatch({
+      type: _reduxServiceMiddleware.CALL_SERVICE,
+      payload: {
+        service: 'outcomes',
+        method: 'upsertArtifact',
+        args: [host, jwt, artifactType, artifactId, contextUuid, outcomeIds]
+      }
+    });
+  };
+};
+
+exports.upsertArtifact = upsertArtifact;

package/lib/translated/vi/store/alignments/reducers.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _reduxActions = require("redux-actions");
+
+var _reduxImmutable = require("redux-immutable");
+
+var _immutable = require("immutable");
+
+var alignedOutcomes = (0, _reduxActions.handleActions)({
+  SET_ALIGNMENTS: function SET_ALIGNMENTS(state, action) {
+    return (0, _immutable.fromJS)(action.payload.outcomes || []);
+  },
+  UPDATE_ALIGNMENT: function UPDATE_ALIGNMENT(state, action) {
+    var outcomeId = action.payload.outcome.id;
+    var idx = state.findIndex(function (o) {
+      return o.get('id') === outcomeId;
+    });
+
+    if (idx === -1) {
+      return state;
+    }
+
+    var outcome = action.payload.outcome;
+    return state.set(idx, (0, _immutable.Map)(outcome));
+  }
+}, (0, _immutable.List)());
+var openAlignmentId = (0, _reduxActions.handleActions)({
+  VIEW_ALIGNMENT: function VIEW_ALIGNMENT(state, action) {
+    return action.payload;
+  },
+  CLOSE_ALIGNMENT: function CLOSE_ALIGNMENT() {
+    return null;
+  }
+}, null);
+var alignmentSetId = (0, _reduxActions.handleActions)({
+  SET_ALIGNMENTS: function SET_ALIGNMENTS(state, action) {
+    return action.payload.guid || null;
+  }
+}, null);
+
+var _default = (0, _reduxImmutable.combineReducers)({
+  alignedOutcomes: alignedOutcomes,
+  openAlignmentId: openAlignmentId,
+  alignmentSetId: alignmentSetId
+});
+
+exports.default = _default;

package/lib/translated/vi/store/alignments/selectors.js

@@ -0,0 +1,84 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAlignedOutcomeCount = getAlignedOutcomeCount;
+exports.getAnyOutcome = getAnyOutcome;
+exports.getOutcomeAlignmentSetId = getOutcomeAlignmentSetId;
+exports.makeIsOpen = exports.getAlignedOutcome = exports.getAlignedOutcomeIds = exports.getAlignedOutcomes = void 0;
+
+var _immutable = require("immutable");
+
+var _reselect = require("reselect");
+
+var _reReselect = _interopRequireDefault(require("re-reselect"));
+
+var _selectors = require("../context/selectors.js");
+
+var restrict = function restrict(state, scope) {
+  return state.getIn([scope, 'alignments']) || (0, _immutable.Map)();
+};
+
+var alignedOutcomes = function alignedOutcomes(state, scope) {
+  return restrict(state, scope).get('alignedOutcomes') || (0, _immutable.List)();
+};
+
+var openAlignmentId = function openAlignmentId(state, scope) {
+  return restrict(state, scope).get('openAlignmentId');
+};
+
+var getAlignedOutcomes = (0, _reReselect.default)(alignedOutcomes, function (alignedOutcomes) {
+  return alignedOutcomes.toJS().sort(function (a, b) {
+    var titleA = a && a.title || 'ZZZZZZZZZZZZ'; // treat null as really large
+
+    var titleB = b && b.title || 'ZZZZZZZZZZZZ'; // treat null as really large
+
+    return titleA.localeCompare(titleB);
+  });
+})(function (_state, scope) {
+  return scope;
+});
+exports.getAlignedOutcomes = getAlignedOutcomes;
+var getAlignedOutcomeIds = (0, _reselect.createSelector)(getAlignedOutcomes, function (outcomes) {
+  return outcomes.map(function (o) {
+    return o.id;
+  });
+});
+exports.getAlignedOutcomeIds = getAlignedOutcomeIds;
+
+function getAlignedOutcomeCount(state, scope) {
+  if (state && restrict(state, scope).get('alignedOutcomes')) {
+    return restrict(state, scope).get('alignedOutcomes').size;
+  }
+
+  return 0;
+}
+
+var getAlignedOutcome = (0, _reselect.createSelector)(function (state, scope, id) {
+  return getAlignedOutcomes(state, scope).find(function (o) {
+    return o.id === id;
+  });
+}, function (outcome) {
+  return outcome;
+});
+exports.getAlignedOutcome = getAlignedOutcome;
+
+function getAnyOutcome(state, scope, id) {
+  return getAlignedOutcome(state, scope, id) || (0, _selectors.getOutcome)(state, scope, id);
+}
+
+function getOutcomeAlignmentSetId(state, scope) {
+  return restrict(state, scope).get('alignmentSetId');
+}
+
+var makeIsOpen = (0, _reReselect.default)(openAlignmentId, function (openAlignments) {
+  return function (id) {
+    return openAlignments === id;
+  };
+})(function (_state, scope) {
+  return scope;
+});
+exports.makeIsOpen = makeIsOpen;

package/lib/translated/vi/store/config/__tests__/reducers.test.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+var _immutable = require("immutable");
+
+var _chai = require("chai");
+
+var _reducers = _interopRequireDefault(require("../reducers.js"));
+
+describe('config/reducers', function () {
+  describe('config', function () {
+    it('remains constant', function () {
+      var reducer = (0, _reducers.default)({
+        host: 'myhost',
+        jwt: 'myjwt'
+      });
+      var newState = reducer((0, _immutable.Map)(), {
+        type: 'foo',
+        payload: 'bar'
+      });
+      (0, _chai.expect)(newState.get('host')).to.equal('myhost');
+      (0, _chai.expect)(newState.get('jwt')).to.equal('myjwt');
+    });
+  });
+});

package/lib/translated/vi/store/config/__tests__/selectors.test.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _chai = require("chai");
+
+var _immutable = require("immutable");
+
+var _selectors = require("../selectors.js");
+
+describe('context/selectors', function () {
+  var state = (0, _immutable.fromJS)({
+    scopeForTest: {
+      config: {
+        foo: 'bar'
+      }
+    }
+  });
+  describe('getConfig', function () {
+    it('retrieves the correct value', function () {
+      (0, _chai.expect)((0, _selectors.getConfig)(state, 'scopeForTest')).to.deep.equal({
+        foo: 'bar'
+      });
+    });
+    it('returns an empty object if no config present', function () {
+      (0, _chai.expect)((0, _selectors.getConfig)((0, _immutable.Map)(), 'scopeForTest')).to.deep.equal({});
+    });
+  });
+});

package/lib/translated/vi/store/config/reducers.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _immutable = require("immutable");
+
+var config = function config(conf) {
+  return function () {
+    return (0, _immutable.fromJS)(conf);
+  };
+};
+
+var _default = config;
+exports.default = _default;

package/lib/translated/vi/store/config/selectors.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getConfig = void 0;
+
+var _immutable = require("immutable");
+
+var _reselect = require("reselect");
+
+function restrict(state, scope) {
+  return state.getIn([scope, 'config']) || (0, _immutable.Map)();
+}
+
+var getConfig = (0, _reselect.createSelector)(restrict, function (config) {
+  return config.toJS();
+});
+exports.getConfig = getConfig;