orc-shared 1.2.0-dev.1 → 1.2.0-dev.13

package/src/reducers/modules.js

@@ -1,8 +1,22 @@
 import Immutable from "immutable";
-import { SET_MODULES_STRUCTURE } from "../actions/modules";
+import {
+	INITIALIZE_FIRST_MODULE_SCOPE,
+	SET_MODULE_AS_VISIBLE,
+	SET_MODULES_STRUCTURE,
+	SET_NEW_SCOPE_AND_MODULE_NAME,
+	SET_ROUTING_PERFORMED,
+} from "../actions/modules";
 import { infoBar } from "./../constants";
 
-const initialState = Immutable.Map({});
+const initialState = Immutable.fromJS({
+	tree: {},
+	visibleModules: [],
+	lastScopeAndModuleSelection: {
+		scope: null,
+		moduleName: null,
+		routingPerformed: true,
+	},
+});
 
 const viewStateReducer = (state = initialState, action) => {
 	switch (action.type) {
@@ -32,6 +46,38 @@ const viewStateReducer = (state = initialState, action) => {
 
 			return state.set("tree", Immutable.fromJS(modulesTree));
 		}
+
+		case INITIALIZE_FIRST_MODULE_SCOPE: {
+			return state.setIn(["lastScopeAndModuleSelection", "scope"], action.payload);
+		}
+
+		case SET_MODULE_AS_VISIBLE: {
+			const visibleModules = state.get("visibleModules").toJS();
+			visibleModules.push(action.payload);
+
+			return state.set("visibleModules", Immutable.fromJS(visibleModules));
+		}
+
+		case SET_NEW_SCOPE_AND_MODULE_NAME: {
+			const lastScopeAndModuleSelection = state.get("lastScopeAndModuleSelection").toJS();
+
+			if (action.payload.scope !== lastScopeAndModuleSelection.scope) {
+				state = state.set("visibleModules", Immutable.fromJS([]));
+			}
+
+			return state.set(
+				"lastScopeAndModuleSelection",
+				Immutable.fromJS({
+					moduleName: action.payload.moduleName,
+					scope: action.payload.scope,
+					routingPerformed: false,
+				}),
+			);
+		}
+
+		case SET_ROUTING_PERFORMED:
+			return state.setIn(["lastScopeAndModuleSelection", "routingPerformed"], true);
+
 		default:
 			return state;
 	}

package/src/reducers/modules.test.js

@@ -1,9 +1,25 @@
 import Immutable from "immutable";
-import { setModulesStructure } from "../actions/modules";
+import {
+	initializeFirstModuleScope,
+	setModuleAsVisible,
+	setModulesStructure,
+	setNewScopeAndModuleName,
+	setRoutingPerformed,
+} from "../actions/modules";
 import modulesReducer from "./modules";
 
 describe("View state reducer", () => {
-	it("behaves as a reducer should", () => expect(modulesReducer, "to be a reducer with initial state", {}));
+	const initialState = {
+		tree: {},
+		visibleModules: [],
+		lastScopeAndModuleSelection: {
+			scope: null,
+			moduleName: null,
+			routingPerformed: true,
+		},
+	};
+
+	it("behaves as a reducer should", () => expect(modulesReducer, "to be a reducer with initial state", initialState));
 
 	it("Sets module structure correctly", () => {
 		const oldState = Immutable.Map({});
@@ -92,4 +108,103 @@ describe("View state reducer", () => {
 		const newState = modulesReducer(oldState, action);
 		return expect(newState, "not to be", oldState).and("to equal", Immutable.fromJS({ tree: modules }));
 	});
+
+	it("Initialize first scope", () => {
+		const oldState = Immutable.fromJS(initialState);
+
+		const expected = {
+			...initialState,
+			lastScopeAndModuleSelection: {
+				...initialState.lastScopeAndModuleSelection,
+				scope: "firstScope",
+			},
+		};
+
+		const action = initializeFirstModuleScope("firstScope");
+		const newState = modulesReducer(oldState, action);
+		return expect(newState, "not to be", oldState).and("to equal", Immutable.fromJS(expected));
+	});
+
+	it("Add a visible module into the array", () => {
+		const oldState = Immutable.fromJS({
+			...initialState,
+			visibleModules: ["moduleReality"],
+		});
+
+		const expected = {
+			...initialState,
+			visibleModules: ["moduleReality", "moduleMatrix"],
+		};
+
+		const action = setModuleAsVisible("moduleMatrix");
+		const newState = modulesReducer(oldState, action);
+		return expect(newState, "not to be", oldState).and("to equal", Immutable.fromJS(expected));
+	});
+
+	it("set a new scope and module for eventual redirection", () => {
+		const oldState = Immutable.fromJS({
+			...initialState,
+			lastScopeAndModuleSelection: {
+				scope: "aScope",
+				moduleName: null,
+				routingPerformed: true,
+			},
+		});
+
+		const expected = {
+			...initialState,
+			lastScopeAndModuleSelection: {
+				scope: "aScope",
+				moduleName: "moduleMatrix",
+				routingPerformed: false,
+			},
+		};
+
+		const action = setNewScopeAndModuleName("aScope", "moduleMatrix");
+		const newState = modulesReducer(oldState, action);
+		return expect(newState, "not to be", oldState).and("to equal", Immutable.fromJS(expected));
+	});
+
+	it("set a new scope and module for eventual redirection and reinitialize visible modules", () => {
+		const oldState = Immutable.fromJS({
+			...initialState,
+			visibleModules: ["moduleReality"],
+		});
+
+		const expected = {
+			...initialState,
+			lastScopeAndModuleSelection: {
+				scope: "newScope",
+				moduleName: "moduleMatrix",
+				routingPerformed: false,
+			},
+		};
+
+		const action = setNewScopeAndModuleName("newScope", "moduleMatrix");
+		const newState = modulesReducer(oldState, action);
+		return expect(newState, "not to be", oldState).and("to equal", Immutable.fromJS(expected));
+	});
+
+	it("set routing was perform on scope and module", () => {
+		const oldState = Immutable.fromJS({
+			...initialState,
+			lastScopeAndModuleSelection: {
+				scope: "aScope",
+				moduleName: "aModule",
+				routingPerformed: false,
+			},
+		});
+		const expected = {
+			...initialState,
+			lastScopeAndModuleSelection: {
+				scope: "aScope",
+				moduleName: "aModule",
+				routingPerformed: true,
+			},
+		};
+
+		const action = setRoutingPerformed();
+		const newState = modulesReducer(oldState, action);
+		return expect(newState, "not to be", oldState).and("to equal", Immutable.fromJS(expected));
+	});
 });

package/src/reducers/scopes.js

@@ -8,7 +8,37 @@ const initialState = Immutable.fromJS({});
 const scopeReducer = (state = initialState, action) => {
 	switch (action.type) {
 		case GET_SCOPES_SUCCESS: {
+			const loadedScopes = state.toJS();
 			const normalizedScopes = normalize(action.payload, scopeSchema);
+
+			if (Object.keys(loadedScopes).length > 0) {
+				const addedScope = {};
+
+				Object.values(normalizedScopes.entities.scopes).forEach(scope => {
+					if (!loadedScopes[scope.id]) {
+						loadedScopes[scope.id] = scope;
+						addedScope[scope.id] = scope;
+					} else if (scope.isAuthorizedScope) {
+						loadedScopes[scope.id] = scope;
+					}
+				});
+
+				Object.values(addedScope).forEach(scope => {
+					const parentScope = loadedScopes[scope.parentScopeId];
+
+					if (parentScope) {
+						if (!parentScope.children.includes(scope.id)) {
+							parentScope.children.push(scope.id);
+						}
+					} else {
+						// Should not happen, but for safety
+						delete loadedScopes[scope.id];
+					}
+				});
+
+				return state.merge(Immutable.fromJS(loadedScopes));
+			}
+
 			return state.merge(Immutable.fromJS(normalizedScopes.entities.scopes));
 		}
 		default:

package/src/reducers/scopes.test.js

@@ -6,7 +6,7 @@ describe("scopes", () => {
 	it("behaves as a reducer should", () => expect(reducer, "to be a reducer with initial state", {}));
 
 	it("saves a normalized index of scopes with child lists, keys all lower case", () => {
-		const oldState = Immutable.Map({ Global: {} });
+		const oldState = Immutable.Map({});
 		const action = {
 			type: GET_SCOPES_SUCCESS,
 			payload: {
@@ -47,4 +47,48 @@ describe("scopes", () => {
 			}),
 		);
 	});
+
+	it("updates a normalized index of scopes with child lists, keys all lower case", () => {
+		const oldState = Immutable.Map({
+			Global: {
+				id: "Global",
+				isAuthorizedScope: false,
+				children: ["Child1", "Child2", "Child3"],
+				scopePath: ["Global"],
+			},
+			Child1: { id: "Child1", isAuthorizedScope: true, scopePath: ["Global", "Child1"], children: [] },
+			Child2: { id: "Child2", isAuthorizedScope: false, scopePath: ["Global", "Child2"], children: [] },
+		});
+
+		const action = {
+			type: GET_SCOPES_SUCCESS,
+			payload: {
+				id: "Global",
+				isAuthorized: false,
+				children: [
+					{ id: "Child1", isAuthorizedScope: false, children: [], parentScopeId: "Global" },
+					{ id: "Child2", isAuthorizedScope: true, children: [], parentScopeId: "Global" },
+					{ id: "Child3", isAuthorizedScope: false, children: [], parentScopeId: "Global" },
+					{ id: "Child4", isAuthorizedScope: true, children: [], parentScopeId: "Global" },
+					{ id: "Child5", isAuthorizedScope: true, children: [], parentScopeId: "UnknownParent" },
+				],
+			},
+		};
+		const newState = reducer(oldState, action);
+		return expect(newState, "not to be", oldState).and(
+			"to satisfy",
+			Immutable.fromJS({
+				Global: {
+					id: "Global",
+					isAuthorizedScope: false,
+					children: ["Child1", "Child2", "Child3", "Child4"],
+					scopePath: ["Global"],
+				},
+				Child1: { id: "Child1", isAuthorizedScope: true, scopePath: ["Global", "Child1"], children: [] },
+				Child2: { id: "Child2", isAuthorizedScope: true, scopePath: ["Global", "Child2"], children: [] },
+				Child3: { id: "Child3", isAuthorizedScope: false, scopePath: ["Global", "Child3"], children: [] },
+				Child4: { id: "Child4", isAuthorizedScope: true, scopePath: ["Global", "Child4"], children: [] },
+			}),
+		);
+	});
 });

package/src/reducers/settings.js

@@ -3,19 +3,43 @@ import addSpawner from "../spawnerMiddleware";
 import { changeLocale } from "../actions/locale";
 import { GET_MY_CULTURE_SUCCESS } from "../actions/locale";
 import { GET_MY_APPLICATION_SUCCESS, SET_MY_APPLICATION_SUCCESS } from "../actions/applications";
-import { GET_MY_SCOPE_SUCCESS } from "../actions/scopes";
+import {
+	GET_APPLICATION_MODULES_SUCCESS,
+	GET_MY_SCOPE_SUCCESS,
+	GET_SCOPES_FAILURE,
+	GET_SCOPES_SUCCESS,
+} from "../actions/scopes";
+import { overtureModule } from "../constants";
 
-const initialState = Immutable.Map({
+const initialState = Immutable.fromJS({
 	defaultApp: 0,
 	defaultScope: null,
+	loadedModulesScope: [],
+	modules: [],
 });
 
+const setLoadedModulesScope = (state, module) => {
+	const loadedModulesScope = state.get("loadedModulesScope").toJS();
+	loadedModulesScope.push(module);
+	return state.set("loadedModulesScope", Immutable.fromJS(loadedModulesScope));
+};
+
 const settingsReducer = (state = initialState, action) => {
 	switch (action.type) {
+		case GET_APPLICATION_MODULES_SUCCESS:
+			return state.set("modules", Immutable.fromJS(action.payload.map(x => overtureModule[x.name])));
 		case GET_MY_APPLICATION_SUCCESS:
 			return state.set("defaultApp", action.payload.id);
 		case SET_MY_APPLICATION_SUCCESS:
 			return state.set("defaultApp", action.meta.appId);
+		case GET_SCOPES_SUCCESS:
+			return setLoadedModulesScope(state, action.meta.module);
+		case GET_SCOPES_FAILURE: {
+			if (action.payload.status === 500) {
+				state = setLoadedModulesScope(state, action.meta.module);
+			}
+			return state;
+		}
 		case GET_MY_SCOPE_SUCCESS:
 			return state.set("defaultScope", action.payload.id);
 		default:

package/src/reducers/settings.test.js

@@ -1,14 +1,22 @@
 import Immutable from "immutable";
 import reducer from "./settings";
 import { GET_MY_APPLICATION_SUCCESS, SET_MY_APPLICATION_SUCCESS } from "../actions/applications";
-import { GET_MY_SCOPE_SUCCESS } from "../actions/scopes";
+import {
+	GET_APPLICATION_MODULES_SUCCESS,
+	GET_MY_SCOPE_SUCCESS,
+	GET_SCOPES_FAILURE,
+	GET_SCOPES_SUCCESS,
+} from "../actions/scopes";
 
 describe("settings", () => {
-	it("behaves as a reducer should", () =>
-		expect(reducer, "to be a reducer with initial state", {
-			defaultApp: 0,
-			defaultScope: null,
-		}));
+	const initialState = Immutable.fromJS({
+		defaultApp: 0,
+		defaultScope: null,
+		loadedModulesScope: [],
+		modules: [],
+	});
+
+	it("behaves as a reducer should", () => expect(reducer, "to be a reducer with initial state", initialState));
 
 	it("stores results of getting your personal default application", () => {
 		const oldState = Immutable.fromJS({
@@ -65,4 +73,64 @@ describe("settings", () => {
 			defaultScope: "aScope",
 		});
 	});
+
+	it("stores modules for the application", () => {
+		const oldState = Immutable.fromJS({
+			modules: [],
+		});
+		const action = {
+			type: GET_APPLICATION_MODULES_SUCCESS,
+			payload: [{ name: "Customers" }, { name: "Orders" }, { name: "Administration" }],
+		};
+		const newState = reducer(oldState, action);
+		expect(newState, "not to be", oldState).and("to satisfy", {
+			modules: ["Customer", "Order", "Administration"],
+		});
+	});
+
+	it("stores module as loaded when it is a success", () => {
+		const oldState = Immutable.fromJS({
+			loadedModulesScope: [],
+		});
+		const action = {
+			type: GET_SCOPES_SUCCESS,
+			meta: { module: "Order" },
+		};
+		const newState = reducer(oldState, action);
+		expect(newState, "not to be", oldState).and("to satisfy", {
+			loadedModulesScope: ["Order"],
+		});
+	});
+
+	it("stores module as loaded when it is a failure with status 500", () => {
+		const oldState = Immutable.fromJS({
+			loadedModulesScope: [],
+		});
+		const action = {
+			type: GET_SCOPES_FAILURE,
+			payload: {
+				status: 500,
+			},
+			meta: { module: "Order" },
+		};
+		const newState = reducer(oldState, action);
+		expect(newState, "not to be", oldState).and("to satisfy", {
+			loadedModulesScope: ["Order"],
+		});
+	});
+
+	it("does not store module as loaded when it is a failure with other errors", () => {
+		const oldState = Immutable.fromJS({
+			loadedModulesScope: [],
+		});
+		const action = {
+			type: GET_SCOPES_FAILURE,
+			payload: {
+				status: 404,
+			},
+			meta: { module: "Order" },
+		};
+		const newState = reducer(oldState, action);
+		expect(newState, "to be", oldState);
+	});
 });

package/src/selectors/authentication.js

@@ -1,6 +1,7 @@
 import { createSelector } from "reselect";
 import { platformRoles } from "./../constants";
 import { getCurrentScope } from "./navigation";
+import { getScopesSelector } from "./scope";
 
 const authData = state => state.get("authentication");
 
@@ -11,35 +12,60 @@ export const selectRolesClaims = createSelector(authData, data => data.get("role
 export const selectGroupRolesClaims = roleGroup =>
 	createSelector(selectRolesClaims, rolesClaims => rolesClaims.get(roleGroup) || null);
 
-export const hasEditorPermissions = roleGroup =>
-	createSelector(selectGroupRolesClaims(roleGroup), getCurrentScope, (appRolesClaims, currentScope) => {
-		if (appRolesClaims != null) {
-			return (
-				!!appRolesClaims.getIn(["*", platformRoles.Editor]) ||
-				!!appRolesClaims.getIn([currentScope, platformRoles.Editor])
-			);
+const hasRolePermissions = (appRolesClaims, scopeId, role, scopes) => {
+	if (appRolesClaims != null && scopeId != null) {
+		const allowed = !!appRolesClaims.getIn(["*", role]) || !!appRolesClaims.getIn([scopeId, role]);
+
+		if (!allowed) {
+			const parentScopeId = scopes.get(scopeId)?.toJS()?.parentScopeId ?? null;
+
+			return hasRolePermissions(appRolesClaims, parentScopeId, role, scopes);
 		}
-		return false;
-	});
+
+		return allowed;
+	}
+
+	return false;
+};
+
+export const hasEditorPermissions = roleGroup =>
+	createSelector(
+		selectGroupRolesClaims(roleGroup),
+		getCurrentScope,
+		getScopesSelector,
+		(appRolesClaims, currentScope, scopes) =>
+			hasRolePermissions(appRolesClaims, currentScope, platformRoles.Editor, scopes),
+	);
+
+export const hasEditorPermissionsForScope = (scope, roleGroup) =>
+	createSelector(selectGroupRolesClaims(roleGroup), getScopesSelector, (appRolesClaims, scopes) =>
+		hasRolePermissions(appRolesClaims, scope, platformRoles.Editor, scopes),
+	);
 
 export const hasAdministratorPermissions = roleGroup =>
-	createSelector(selectGroupRolesClaims(roleGroup), getCurrentScope, (appRolesClaims, currentScope) => {
-		if (appRolesClaims != null) {
-			return (
-				!!appRolesClaims.getIn(["*", platformRoles.Administrator]) ||
-				!!appRolesClaims.getIn([currentScope, platformRoles.Administrator])
-			);
-		}
-		return false;
-	});
+	createSelector(
+		selectGroupRolesClaims(roleGroup),
+		getCurrentScope,
+		getScopesSelector,
+		(appRolesClaims, currentScope, scopes) =>
+			hasRolePermissions(appRolesClaims, currentScope, platformRoles.Administrator, scopes),
+	);
+
+export const hasAdministratorPermissionsForScope = (scope, roleGroup) =>
+	createSelector(selectGroupRolesClaims(roleGroup), getScopesSelector, (appRolesClaims, scopes) =>
+		hasRolePermissions(appRolesClaims, scope, platformRoles.Administrator, scopes),
+	);
 
 export const hasReaderPermissions = roleGroup =>
-	createSelector(selectGroupRolesClaims(roleGroup), getCurrentScope, (appRolesClaims, currentScope) => {
-		if (appRolesClaims != null) {
-			return (
-				!!appRolesClaims.getIn(["*", platformRoles.Reader]) ||
-				!!appRolesClaims.getIn([currentScope, platformRoles.Reader])
-			);
-		}
-		return false;
-	});
+	createSelector(
+		selectGroupRolesClaims(roleGroup),
+		getCurrentScope,
+		getScopesSelector,
+		(appRolesClaims, currentScope, scopes) =>
+			hasRolePermissions(appRolesClaims, currentScope, platformRoles.Reader, scopes),
+	);
+
+export const hasReaderPermissionsForScope = (scope, roleGroup) =>
+	createSelector(selectGroupRolesClaims(roleGroup), getScopesSelector, (appRolesClaims, scopes) =>
+		hasRolePermissions(appRolesClaims, scope, platformRoles.Reader, scopes),
+	);