@instructure/outcomes-ui 3.1.0 → 3.2.1

package/es/translated/ca/store/OutcomePicker/__tests__/actions.test.js

@@ -85,6 +85,75 @@ describe('OutcomePicker/actions', function () {
       });
     });
   });
+  describe('loadSelectedLaunchContext', function () {
+    it('does not setSelectedLaunchContext when there is no launch context', function () {
+      var store = createMockStore(Map(fromJS({
+        scopeForTest: {
+          alignments: {}
+        }
+      })));
+      store.dispatch(actions.loadSelectedLaunchContext());
+      expect(store.getActions().length).to.equal(0);
+    });
+    it('does not setSelectedLaunchContext when launch context is empty', function () {
+      var store = createMockStore(Map(fromJS({
+        scopeForTest: {
+          alignments: {
+            launchContexts: []
+          }
+        }
+      })));
+      store.dispatch(actions.loadSelectedLaunchContext());
+      expect(store.getActions().length).to.equal(0);
+    });
+    it('does not setSelectedLaunchContext when already selected', function () {
+      var store = createMockStore(Map(fromJS({
+        scopeForTest: {
+          alignments: {},
+          OutcomePicker: {
+            selectedLaunchContext: {
+              uuid: 'foo',
+              name: 'Dave University'
+            }
+          }
+        }
+      })));
+      store.dispatch(actions.loadSelectedLaunchContext());
+      expect(store.getActions().length).to.equal(0);
+    });
+    it('setSelectedLaunchContext when launch context is not empty', function () {
+      var store = createMockStore(Map(fromJS({
+        scopeForTest: {
+          alignments: {
+            launchContexts: [{
+              uuid: 'foo',
+              name: 'Dave University'
+            }]
+          }
+        }
+      })));
+      store.dispatch(actions.loadSelectedLaunchContext());
+      expect(store.getActions().length).to.equal(1);
+      expect(store.getActions()[0]).to.deep.equal(scopedActions.setSelectedLaunchContext({
+        uuid: 'foo',
+        name: 'Dave University'
+      }));
+    });
+  });
+  describe('changeSelectedLaunchContext', function () {
+    it('updates selected launch context', function () {
+      var store = createMockStore();
+      return store.dispatch(actions.changeSelectedLaunchContext({
+        uuid: 'uuid',
+        name: 'name'
+      })).then(function () {
+        expect(store.getActions()).to.deep.include(scopedActions.setSelectedLaunchContext({
+          uuid: 'uuid',
+          name: 'name'
+        }));
+      });
+    });
+  });
   describe('setActiveCollection', function () {
     it('sets the underlying collection id', function () {
       var store = createMockStore();
@@ -146,13 +215,13 @@ describe('OutcomePicker/actions', function () {
         return null;
       });
     });
-    it('fetches an outcome and dispatches setFocusedOutcomeAction twice with selected shared context', function () {
+    it('fetches an outcome and dispatches setFocusedOutcomeAction twice with selected launch context', function () {
       var state = fromJS({
         scopeForTest: {
           OutcomePicker: {
-            selectedSharedContext: {
-              uuid: 'selectedSharedContext',
-              name: 'selectedSharedContext'
+            selectedLaunchContext: {
+              uuid: 'selectedLaunchContext',
+              name: 'selectedLaunchContext'
             }
           }
         }
@@ -173,13 +242,13 @@ describe('OutcomePicker/actions', function () {
         expect(store.getActions()).to.have.length(4);
         expect(store.getActions()[0]).to.deep.equal(scopedActions.setFocusedOutcomeAction(partial));
         expect(store.getActions()[2]).to.deep.equal(scopedActions.setScoringMethod({
-          context_uuid: 'selectedSharedContext',
+          context_uuid: 'selectedLaunchContext',
           id: 1,
           scoring_method: {}
         }));
         expect(store.getActions()[3]).to.deep.equal(scopedActions.setFocusedOutcomeAction(full));
         expect(service.getOutcome.calledOnce).to.be.true;
-        expect(service.getOutcome.getCall(0).args).to.include('selectedSharedContext');
+        expect(service.getOutcome.getCall(0).args).to.include('selectedLaunchContext');
         return null;
       });
     });
@@ -209,7 +278,17 @@ describe('OutcomePicker/actions', function () {
       }
     });
     it('wraps its calls in setOutcomePickerState', function () {
-      var store = createMockStore(state);
+      var service = {
+        createAlignmentSet: sinon.stub().returns(Promise.resolve({
+          guid: 'newguid',
+          outcomes: [{
+            id: '1'
+          }, {
+            id: '2'
+          }]
+        }))
+      };
+      var store = createMockStore(state, service);
       return store.dispatch(actions.saveOutcomePickerAlignments()).then(function () {
         expect(store.getActions()[0]).to.deep.equal(scopedActions.setOutcomePickerState('saving'));
         expect(store.getActions()).to.deep.include(scopedActions.setAlignments({
@@ -224,7 +303,17 @@ describe('OutcomePicker/actions', function () {
       });
     });
     it('fires an updateCallback function if provided', function () {
-      var store = createMockStore(state);
+      var service = {
+        createAlignmentSet: sinon.stub().returns(Promise.resolve({
+          guid: 'newguid',
+          outcomes: [{
+            id: '1'
+          }, {
+            id: '2'
+          }]
+        }))
+      };
+      var store = createMockStore(state, service);
       var callback = sinon.stub();
       return store.dispatch(actions.saveOutcomePickerAlignments(callback)).then(function () {
         expect(callback.calledOnce).to.be.true;
@@ -239,14 +328,14 @@ describe('OutcomePicker/actions', function () {
       });
     });
     it('creates alignment set from selection', function () {
-      var newState = state.setIn(['OutcomePicker', 'selected'], List(['1', '2', '3']));
+      var newState = state.setIn(['scopeForTest', 'OutcomePicker', 'selected'], List(['1', '2', '3']));
       var service = {
         createAlignmentSet: sinon.stub().returns(Promise.resolve())
       };
       var store = createMockStore(newState, service);
       return store.dispatch(actions.saveOutcomePickerAlignments()).then(function () {
         expect(service.createAlignmentSet.calledOnce).to.be.true;
-        expect(service.createAlignmentSet.calledWith(['1', '2', '3']));
+        expect(service.createAlignmentSet.getCall(0).args[2]).to.deep.equal(['1', '2', '3']);
       });
     });
     it('can pull aligned outcomes from previously aligned outcomes', function () {
@@ -258,7 +347,8 @@ describe('OutcomePicker/actions', function () {
       };
       var store = createMockStore(newState, service);
       return store.dispatch(actions.saveOutcomePickerAlignments()).then(function () {
-        expect(service.createAlignmentSet.calledWith(['1', '2']));
+        expect(service.createAlignmentSet.calledOnce).to.be.true;
+        expect(service.createAlignmentSet.getCall(0).args[2]).to.deep.equal(['1', '2']);
       });
     });
     it('dispatches setError on save alignments failure', function () {
@@ -284,7 +374,8 @@ describe('OutcomePicker/actions', function () {
       };
       var store = createMockStore(state, service);
       return store.dispatch(actions.saveOutcomePickerAlignments(null, true)).then(function () {
-        expect(service.upsertArtifact.calledWith(['1', '2']));
+        expect(service.upsertArtifact.calledOnce).to.be.true;
+        expect(service.upsertArtifact.getCall(0).args[5]).to.deep.equal(['1', '2']);
         expect(store.getActions()).to.deep.include(scopedActions.setAlignments({
           guid: 'guid-1',
           outcomes: [{

package/es/translated/ca/store/OutcomePicker/actions.js

@@ -1,15 +1,14 @@
 import { createAction } from 'redux-actions';
 import { CALL_SERVICE } from '@instructure/redux-service-middleware';
 import { getConfig } from "../config/selectors.js";
-import { SELECT_OUTCOME_IDS, UNSELECT_OUTCOME_IDS, SET_SELECTED_OUTCOME_IDS, SET_OUTCOME_PICKER_STATE, SET_FOCUSED_OUTCOME, SET_ACTIVE_COLLECTION_ID, TOGGLE_EXPANDED_IDS, RESET_OUTCOME_PICKER, SET_SHARED_CONTEXTS, SET_SELECTED_SHARED_CONTEXT, RESET_EXPANDED_IDS } from "../../constants.js";
+import { SELECT_OUTCOME_IDS, UNSELECT_OUTCOME_IDS, SET_SELECTED_OUTCOME_IDS, SET_OUTCOME_PICKER_STATE, SET_FOCUSED_OUTCOME, SET_ACTIVE_COLLECTION_ID, TOGGLE_EXPANDED_IDS, RESET_OUTCOME_PICKER, SET_SELECTED_LAUNCH_CONTEXT, RESET_EXPANDED_IDS } from "../../constants.js";
 import { loadRootOutcomes, loadMoreOutcomes, setError, setScoringMethod } from "../context/actions.js";
-import { getAlignedOutcomeIds, getAnyOutcome } from "../alignments/selectors.js";
-import { getSelectedOutcomeIds, getOutcomePickerState, getSelectedSharedContext, getSharedContexts } from "./selectors.js";
+import { getAlignedOutcomeIds, getAnyOutcome, getLaunchContexts } from "../alignments/selectors.js";
+import { getSelectedOutcomeIds, getOutcomePickerState, getSelectedLaunchContext } from "./selectors.js";
 import { createAlignmentSet, updateAlignments, upsertArtifact } from "../alignments/actions.js";
 import { setScope } from "../activePicker/actions.js";
 import { Set } from 'immutable';
-export var setSharedContexts = createAction(SET_SHARED_CONTEXTS);
-export var setSelectedSharedContext = createAction(SET_SELECTED_SHARED_CONTEXT);
+export var setSelectedLaunchContext = createAction(SET_SELECTED_LAUNCH_CONTEXT);
 export var selectOutcomeIds = createAction(SELECT_OUTCOME_IDS);
 export var deselectOutcomeIds = createAction(UNSELECT_OUTCOME_IDS);
 export var setSelectedOutcomeIds = createAction(SET_SELECTED_OUTCOME_IDS);
@@ -19,26 +18,19 @@ export var setFocusedOutcomeAction = createAction(SET_FOCUSED_OUTCOME);
 export var toggleExpandedIds = createAction(TOGGLE_EXPANDED_IDS);
 export var resetExpandedIds = createAction(RESET_EXPANDED_IDS);
 export var resetOutcomePicker = createAction(RESET_OUTCOME_PICKER);
-export var loadSharedContexts = function loadSharedContexts(sharedContexts) {
-  return function (dispatch, _getState) {
-    return dispatch(setSharedContexts(sharedContexts));
-  };
-};
-export var loadSelectedSharedContext = function loadSelectedSharedContext() {
+export var loadSelectedLaunchContext = function loadSelectedLaunchContext() {
   return function (dispatch, getState, _arg, scope) {
-    var selected = getSelectedSharedContext(getState(), scope);
-    var sharedContexts = getSharedContexts(getState(), scope);
-    if (sharedContexts === null || selected) {
-      return Promise.resolve();
+    var selected = getSelectedLaunchContext(getState(), scope);
+    var launchContexts = getLaunchContexts(getState(), scope);
+    if (launchContexts && launchContexts.length > 0 && !selected) {
+      dispatch(setSelectedLaunchContext(launchContexts[0]));
     }
-    return dispatch(setSelectedSharedContext(sharedContexts[0]));
   };
 };
-export var loadOutcomePicker = function loadOutcomePicker(sharedContexts) {
+export var loadOutcomePicker = function loadOutcomePicker() {
   return function (dispatch, getState, _arg, scope) {
     dispatch(setOutcomePickerState('loading'));
-    dispatch(loadSharedContexts(sharedContexts));
-    dispatch(loadSelectedSharedContext());
+    dispatch(loadSelectedLaunchContext());
     return dispatch(loadRootOutcomes()).then(function () {
       return dispatch(setSelectedOutcomeIds(getAlignedOutcomeIds(getState(), scope)));
     }).then(function () {
@@ -48,10 +40,10 @@ export var loadOutcomePicker = function loadOutcomePicker(sharedContexts) {
     }); // allows chaining other thunks
   };
 };
-export var changeSelectedSharedContext = function changeSelectedSharedContext(newSelectedSharedContext) {
+export var changeSelectedLaunchContext = function changeSelectedLaunchContext(newSelectedLaunchContext) {
   return function (dispatch, getState, _arg, scope) {
     dispatch(setOutcomePickerState('loading'));
-    dispatch(setSelectedSharedContext(newSelectedSharedContext));
+    dispatch(setSelectedLaunchContext(newSelectedLaunchContext));
     // Reset activeCollection and expanded ids since we are moving to another context hierarchy
     dispatch(setActiveCollectionFrd(null));
     dispatch(resetExpandedIds(Set()));
@@ -78,7 +70,7 @@ export var setFocusedOutcome = function setFocusedOutcome(outcome) {
       host = _getConfig.host,
       jwt = _getConfig.jwt,
       contextUuid = _getConfig.contextUuid;
-    var selected = getSelectedSharedContext(getState(), scope);
+    var selected = getSelectedLaunchContext(getState(), scope);
     var context = (selected === null || selected === void 0 ? void 0 : selected.uuid) || contextUuid;
     // First dispatch brings up the outcome view,
     // second dispatch provides the scoring method
@@ -106,12 +98,15 @@ export var saveOutcomePickerAlignments = function saveOutcomePickerAlignments(up
     dispatch(setOutcomePickerState('saving'));
     var state = getState();
     var outcomeIds = getSelectedOutcomeIds(state, scope);
-    var outcomes = outcomeIds.map(function (id) {
-      return getAnyOutcome(state, scope, id);
-    });
     var updateAlignmentFunc = shouldUpdateArtifact ? upsertArtifact : createAlignmentSet;
     return dispatch(updateAlignmentFunc(outcomeIds)).then(function (response) {
-      return dispatch(updateAlignments(response.guid, outcomes, updateCallback));
+      if (shouldUpdateArtifact) {
+        var outcomes = outcomeIds.map(function (id) {
+          return getAnyOutcome(state, scope, id);
+        });
+        return dispatch(updateAlignments(response.guid, outcomes, updateCallback));
+      }
+      return dispatch(updateAlignments(response.guid, response.outcomes, updateCallback));
     }).then(function () {
       return dispatch(setOutcomePickerState('complete'));
     }).catch(function (err) {

package/es/translated/ca/store/OutcomePicker/reducers.js

@@ -6,13 +6,8 @@ import { RESET_OUTCOME_PICKER } from "../../constants.js";
 import { resetExpandedIds, setFocusedOutcomeAction, toggleExpandedIds } from "./actions.js";
 import search from "../search/reducers.js";
 import tray from "../OutcomeTray/reducers.js";
-var sharedContexts = handleActions({
-  SET_SHARED_CONTEXTS: function SET_SHARED_CONTEXTS(state, action) {
-    return fromJS(action.payload);
-  }
-}, null);
-var selectedSharedContext = handleActions({
-  SET_SELECTED_SHARED_CONTEXT: function SET_SELECTED_SHARED_CONTEXT(state, action) {
+var selectedLaunchContext = handleActions({
+  SET_SELECTED_LAUNCH_CONTEXT: function SET_SELECTED_LAUNCH_CONTEXT(state, action) {
     return fromJS(action.payload);
   }
 }, null);
@@ -54,8 +49,7 @@ var state = handleActions({
   }
 }, 'closed');
 var OutcomePickerReducer = combineReducers({
-  sharedContexts: sharedContexts,
-  selectedSharedContext: selectedSharedContext,
+  selectedLaunchContext: selectedLaunchContext,
   state: state,
   selected: selected,
   focusedOutcome: focusedOutcome,

package/es/translated/ca/store/OutcomePicker/selectors.js

@@ -31,15 +31,10 @@ export var makeIsOutcomeSelected = createCachedSelector(selectedOutcomeIds, func
 })(function (_state, scope) {
   return scope;
 });
-export var getSharedContexts = createSelector(function (state, scope) {
-  return restrict(state, scope).get('sharedContexts');
-}, function (sharedContexts) {
-  return sharedContexts ? sharedContexts.toJS() : null;
-});
-export var getSelectedSharedContext = createSelector(function (state, scope) {
-  return restrict(state, scope).get('selectedSharedContext');
-}, function (selectedSharedContext) {
-  return selectedSharedContext ? selectedSharedContext.toJS() : null;
+export var getSelectedLaunchContext = createSelector(function (state, scope) {
+  return restrict(state, scope).get('selectedLaunchContext');
+}, function (selectedLaunchContext) {
+  return selectedLaunchContext ? selectedLaunchContext.toJS() : null;
 });
 export function anyOutcomeSelected(state, scope) {
   var ids = restrict(state, scope).get('selected');

package/es/translated/ca/store/alignments/__tests__/actions.test.js

@@ -1,3 +1,4 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import { Map, fromJS } from 'immutable';
 import { expect } from 'chai';
@@ -180,6 +181,84 @@ describe('alignments/actions', function () {
         return null;
       });
     });
+    it('does not set launch contexts to empty array ', function () {
+      var service = {
+        getAlignments: sinon.stub().returns({
+          guid: 'guid',
+          outcomes: []
+        })
+      };
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.loadAlignments('hexadecimal', [])).then(function () {
+        var _iterator = _createForOfIteratorHelper(store.getActions()),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var action = _step.value;
+            expect(action.type).to.not.equal('SET_LAUNCH_CONTEXTS');
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        expect(service.getAlignments.calledOnce).to.be.true;
+        return null;
+      });
+    });
+    it('sets Launch context if one is supplied', function () {
+      var service = {
+        getAlignments: sinon.stub().returns({
+          guid: 'guid',
+          outcomes: []
+        })
+      };
+      var store = createMockStore(Map(), service);
+      return store.dispatch(actions.loadAlignments('hexadecimal', [{
+        uuid: 'foo',
+        name: 'Dave University'
+      }])).then(function () {
+        expect(store.getActions()[0]).to.deep.equal(scopedActions.setLaunchContexts([{
+          uuid: 'foo',
+          name: 'Dave University'
+        }]));
+        expect(service.getAlignments.calledOnce).to.be.true;
+        return null;
+      });
+    });
+    it('calls outcome service with launchContext to load alignments', function () {
+      var service = {
+        getAlignments: sinon.stub().returns(Promise.resolve())
+      };
+      var store = createMockStore(Map(fromJS({
+        scopeForTest: {
+          alignments: {
+            launchContexts: [{
+              uuid: 'foo',
+              name: 'Dave University'
+            }]
+          }
+        }
+      })), service);
+      return store.dispatch(actions.loadAlignments('hexadecimal')).then(function () {
+        // launch contexts is not passed to loadAlignments. Instead, it is read from the store.
+        var _iterator2 = _createForOfIteratorHelper(store.getActions()),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var action = _step2.value;
+            expect(action.type).to.not.equal('SET_LAUNCH_CONTEXTS');
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        expect(service.getAlignments.calledOnce).to.be.true;
+        expect(service.getAlignments.getCall(0).args).to.include('foo');
+        return null;
+      });
+    });
     it('dispatches setError on outcome service failure', function () {
       var error = {
         message: 'foo bar baz'
@@ -253,7 +332,36 @@ describe('alignments/actions', function () {
       }), service);
       return store.dispatch(actions.removeAlignment('12')).then(function () {
         expect(service.createAlignmentSet.calledOnce).to.be.true;
-        expect(service.createAlignmentSet.calledWith([]));
+        expect(service.createAlignmentSet.getCall(0).args[2]).to.deep.equal(['1']);
+        return null;
+      });
+    });
+    it('calls outcomes service to create new alignment set with launch context', function () {
+      var service = {
+        createAlignmentSet: sinon.stub().returns(Promise.resolve())
+      };
+      var store = createMockStore(fromJS({
+        scopeForTest: {
+          alignments: {
+            alignedOutcomes: [{
+              id: '1'
+            }, {
+              id: '12'
+            }],
+            launchContexts: [{
+              uuid: 'foo',
+              name: 'bar'
+            }, {
+              uuid: 'fuz',
+              name: 'baz'
+            }]
+          }
+        }
+      }), service);
+      return store.dispatch(actions.removeAlignment('12')).then(function () {
+        expect(service.createAlignmentSet.calledOnce).to.be.true;
+        expect(service.createAlignmentSet.getCall(0).args[2]).to.deep.equal(['1']);
+        expect(service.createAlignmentSet.getCall(0).args[3]).to.deep.equal('fuz');
         return null;
       });
     });

package/es/translated/ca/store/alignments/__tests__/reducers.test.js

@@ -1,6 +1,6 @@
 import { expect } from 'chai';
 import { fromJS } from 'immutable';
-import { SET_ALIGNMENTS, VIEW_ALIGNMENT, CLOSE_ALIGNMENT, UPDATE_ALIGNMENT } from "../../../constants.js";
+import { SET_ALIGNMENTS, VIEW_ALIGNMENT, CLOSE_ALIGNMENT, UPDATE_ALIGNMENT, SET_LAUNCH_CONTEXTS } from "../../../constants.js";
 import reducer from "../reducers.js";
 describe('alignments/reducers', function () {
   var reduce = function reduce(state, type, payload) {
@@ -18,6 +18,17 @@ describe('alignments/reducers', function () {
     }],
     openAlignmentId: 10
   });
+  describe('launchContexts', function () {
+    it('is updated by SET_LAUNCH_CONTEXTS', function () {
+      var _newState$get;
+      var newLaunchContexts = [{
+        uuid: 'foo',
+        name: 'Dave University'
+      }];
+      var newState = reduce(state, SET_LAUNCH_CONTEXTS, newLaunchContexts);
+      expect((_newState$get = newState.get('launchContexts')) === null || _newState$get === void 0 ? void 0 : _newState$get.toJS()).to.deep.equal(newLaunchContexts);
+    });
+  });
   describe('alignedOutcomes', function () {
     it('is updated by SET_ALIGNMENTS', function () {
       var newAlignments = {

package/es/translated/ca/store/alignments/__tests__/selectors.test.js

@@ -1,18 +1,18 @@
 import { expect } from 'chai';
 import { Map, fromJS } from 'immutable';
-import { getAlignedOutcomeIds, getAlignedOutcomes, getAlignedOutcome, getAlignedOutcomeCount, getAnyOutcome, makeIsOpen } from "../selectors.js";
+import { getAlignedOutcomeIds, getAlignedOutcomes, getAlignedOutcome, getAlignedOutcomeCount, getAnyOutcome, makeIsOpen, getLaunchContextUuid, getRootAccountContextUuid, isLaunchingFromRootAccount } from "../selectors.js";
 describe('alignments/selectors', function () {
   var state = fromJS({
     scopeForTest: {
       alignments: {
         alignedOutcomes: [{
-          id: '101',
-          label: 'l1',
-          title: 't2'
-        }, {
           id: '102',
           label: 'l2',
           title: 't1'
+        }, {
+          id: '101',
+          label: 'l1',
+          title: 't2'
         }, {
           id: '103',
           label: 'l3',
@@ -118,16 +118,16 @@ describe('alignments/selectors', function () {
       var outcome = getAnyOutcome(state, 'scopeForTest', '1');
       expect(outcome.label).to.equal('l1');
     });
-    it('can pull outcomes from sharedContext outcomes', function () {
+    it('can pull outcomes from launchContext outcomes', function () {
       var state = fromJS({
         scopeForTest: {
           config: {
             contextUuid: 'course_100'
           },
-          OutcomePicker: {
-            sharedContexts: [{
-              uuid: 'sharedContext',
-              name: 'sharedContext'
+          alignments: {
+            launchContexts: [{
+              uuid: 'launchContext',
+              name: 'LaunchContext'
             }]
           }
         },
@@ -141,7 +141,7 @@ describe('alignments/selectors', function () {
                 child_ids: ['2', '3']
               }
             },
-            sharedContext: {
+            launchContext: {
               4: {
                 id: 4,
                 label: 'l4',
@@ -161,4 +161,41 @@ describe('alignments/selectors', function () {
       expect(outcome).to.be.null;
     });
   });
+  describe('launchContexts', function () {
+    var scope = 'scopeForTest';
+    function setLaunchContexts(state, launchContexts) {
+      return state.setIn([scope, 'alignments', 'launchContexts'], fromJS(launchContexts));
+    }
+    it('is null if launchContexts is null', function () {
+      expect(getLaunchContextUuid(state, scope)).to.deep.equal(null);
+    });
+    it('is null if launchContexts is empty', function () {
+      var launchContexts = [];
+      var newState = setLaunchContexts(state, launchContexts);
+      expect(getLaunchContextUuid(newState, scope)).to.deep.equal(null);
+    });
+    it('is only element if launchContexts has one element', function () {
+      var launchContexts = [{
+        uuid: 'foo',
+        name: 'bar'
+      }];
+      var newState = setLaunchContexts(state, launchContexts);
+      expect(getLaunchContextUuid(newState, scope)).to.deep.equal('foo');
+      expect(getRootAccountContextUuid(newState, scope)).to.deep.equal('foo');
+      expect(isLaunchingFromRootAccount(newState, scope)).to.equal(true);
+    });
+    it('is last if launchContexts has multiple entries', function () {
+      var launchContexts = [{
+        uuid: 'foo',
+        name: 'bar'
+      }, {
+        uuid: 'fuz',
+        name: 'baz'
+      }];
+      var newState = setLaunchContexts(state, launchContexts);
+      expect(getLaunchContextUuid(newState, scope)).to.deep.equal('fuz');
+      expect(getRootAccountContextUuid(newState, scope)).to.deep.equal('foo');
+      expect(isLaunchingFromRootAccount(newState, scope)).to.equal(false);
+    });
+  });
 });

package/es/translated/ca/store/alignments/actions.js

@@ -1,16 +1,23 @@
 import { createAction } from 'redux-actions';
 import { CALL_SERVICE } from '@instructure/redux-service-middleware';
-import { SET_ALIGNMENTS, VIEW_ALIGNMENT, CLOSE_ALIGNMENT, UPDATE_ALIGNMENT } from "../../constants.js";
-import { getAlignedOutcomeIds, getAlignedOutcome, getOutcomeAlignmentSetId } from "./selectors.js";
+import { SET_ALIGNMENTS, VIEW_ALIGNMENT, CLOSE_ALIGNMENT, UPDATE_ALIGNMENT, SET_LAUNCH_CONTEXTS } from "../../constants.js";
+import { getAlignedOutcomeIds, getAlignedOutcome, getOutcomeAlignmentSetId, getLaunchContextUuid, isLaunchingFromRootAccount } from "./selectors.js";
 import { getConfig } from "../config/selectors.js";
 import { setError } from "../context/actions.js";
+import { loadSelectedLaunchContext } from "../OutcomePicker/actions.js";
 /*
  * action creators
  */
+export var setLaunchContexts = createAction(SET_LAUNCH_CONTEXTS);
 export var setAlignments = createAction(SET_ALIGNMENTS);
 export var viewAlignmentAction = createAction(VIEW_ALIGNMENT);
 export var closeAlignment = createAction(CLOSE_ALIGNMENT);
 export var updateAlignment = createAction(UPDATE_ALIGNMENT);
+export var loadLaunchContexts = function loadLaunchContexts(launchContexts) {
+  return function (dispatch, _getState) {
+    return dispatch(setLaunchContexts(launchContexts));
+  };
+};
 export var viewAlignment = function viewAlignment(outcomeId) {
   return function (dispatch, getState, _arg, scope) {
     var outcome = getAlignedOutcome(getState(), scope, outcomeId);
@@ -51,22 +58,28 @@ export var updateAlignments = function updateAlignments(guid, outcomes, updateCa
     return Promise.resolve();
   };
 };
-export var loadAlignments = function loadAlignments(alignmentSetId, updateCallback) {
+export var loadAlignments = function loadAlignments(alignmentSetId, launchContexts, updateCallback) {
   return function (dispatch, getState, _arg, scope) {
     if (alignmentSetId && getOutcomeAlignmentSetId(getState(), scope) === alignmentSetId) {
       return Promise.resolve();
     }
+    if (launchContexts && launchContexts.length > 0) {
+      dispatch(loadLaunchContexts(launchContexts));
+      dispatch(loadSelectedLaunchContext());
+    }
     var _getConfig2 = getConfig(getState(), scope),
       host = _getConfig2.host,
       jwt = _getConfig2.jwt,
       contextUuid = _getConfig2.contextUuid;
+    var launchContext = getLaunchContextUuid(getState(), scope);
+    var launchingFromRoot = isLaunchingFromRootAccount(getState(), scope);
     return dispatch(clearAlignmentSet()).then(function () {
       return dispatch({
         type: CALL_SERVICE,
         payload: {
           service: 'outcomes',
           method: 'getAlignments',
-          args: [host, jwt, alignmentSetId, contextUuid]
+          args: [host, jwt, alignmentSetId, contextUuid, launchContext, launchingFromRoot]
         }
       });
     }).then(function (json) {
@@ -87,10 +100,13 @@ export var removeAlignment = function removeAlignment(alignmentId, updateCallbac
     }
     var updateAlignmentFunc = shouldUpdateArtifact ? upsertArtifact : createAlignmentSet;
     return dispatch(updateAlignmentFunc(newIds)).then(function (response) {
-      var newOutcomes = newIds.map(function (id) {
-        return getAlignedOutcome(getState(), scope, id);
-      });
-      dispatch(updateAlignments(response.guid, newOutcomes, updateCallback));
+      if (shouldUpdateArtifact) {
+        var newOutcomes = newIds.map(function (id) {
+          return getAlignedOutcome(getState(), scope, id);
+        });
+        return dispatch(updateAlignments(response.guid, newOutcomes, updateCallback));
+      }
+      return dispatch(updateAlignments(response.guid, response.outcomes, updateCallback));
     }).catch(function (e) {
       return dispatch(setError(e));
     });
@@ -101,12 +117,14 @@ export var createAlignmentSet = function createAlignmentSet(outcomeIds) {
     var _getConfig3 = getConfig(getState(), scope),
       host = _getConfig3.host,
       jwt = _getConfig3.jwt;
+    var launchContext = getLaunchContextUuid(getState(), scope);
+    var launchingFromRoot = isLaunchingFromRootAccount(getState(), scope);
     return dispatch({
       type: CALL_SERVICE,
       payload: {
         service: 'outcomes',
         method: 'createAlignmentSet',
-        args: [host, jwt, outcomeIds]
+        args: [host, jwt, outcomeIds, launchContext, launchingFromRoot]
       }
     });
   };