orc-shared 1.2.0-dev.2 → 1.2.0-dev.6

package/src/selectors/authentication.test.js

@@ -6,8 +6,47 @@ import {
 	hasEditorPermissions,
 	hasAdministratorPermissions,
 	hasReaderPermissions,
+	hasEditorPermissionsForScope,
+	hasAdministratorPermissionsForScope,
+	hasReaderPermissionsForScope,
 } from "./authentication";
 
+const state = {
+	navigation: {
+		route: { location: {}, match: { params: { scope: "Global" } } },
+	},
+	settings: { defaultScope: "Global" },
+	locale: {
+		locale: "fr",
+		supportedLocales: ["en", "fr"],
+	},
+	scopes: {
+		Global: {
+			name: { en: "Global", fr: "Global" },
+			id: "Global",
+			children: ["MyScope"],
+			currency: {
+				displayName: {
+					en: "Euro",
+					fr: "Euro",
+				},
+			},
+			defaultCulture: "en-US",
+		},
+		MyScope: {
+			name: { en: "First child", fr: "Premier fils" },
+			id: "FirstChild",
+			children: ["ChildScope"],
+			parentScopeId: "Global",
+		},
+		ChildScope: {
+			name: { en: "First grandchild", fr: "Premier petit-fils" },
+			id: "FirstGrandchild",
+			parentScopeId: "MyScope",
+		},
+	},
+};
+
 describe("selectCurrentUsername", () => {
 	it("Gets the logged in username", () =>
 		expect(
@@ -142,10 +181,7 @@ describe("hasEditorPermissions", () => {
 			[
 				Immutable.fromJS({
 					authentication: { rolesClaimsValues: claims },
-					navigation: {
-						route: { location: {}, match: { params: { scope: "Global" } } },
-					},
-					settings: { defaultScope: "Global" },
+					...state,
 				}),
 			],
 			"to equal",
@@ -212,6 +248,34 @@ describe("hasEditorPermissions", () => {
 		);
 	});
 
+	it("Retrieves true if user has editor permissions just in specified scope with permission on parents", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				MyScope: {
+					Editor: true,
+				},
+			},
+		});
+
+		expect(
+			hasEditorPermissions,
+			"when called with",
+			["Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+					...state,
+					navigation: {
+						route: { location: {}, match: { params: { scope: "ChildScope" } } },
+					},
+				}),
+			],
+			"to equal",
+			true,
+		);
+	});
+
 	it("Retrieves false if app roles claims are null", () => {
 		expect(
 			hasEditorPermissions,
@@ -233,6 +297,164 @@ describe("hasEditorPermissions", () => {
 	});
 });
 
+describe("hasEditorPermissionsForScope", () => {
+	it("Retrieves true if user has editor permissions in specified group", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				"*": {
+					Editor: true,
+				},
+			},
+		});
+
+		expect(
+			hasEditorPermissionsForScope,
+			"when called with",
+			["Global", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+				}),
+			],
+			"to equal",
+			true,
+		);
+	});
+
+	it("Retrieves false if user has not editor permissions in specified group", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				"*": {
+					Editor: false,
+				},
+			},
+		});
+
+		expect(
+			hasEditorPermissionsForScope,
+			"when called with",
+			["Global", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+					...state,
+				}),
+			],
+			"to equal",
+			false,
+		);
+	});
+
+	it("Retrieves true if user hasn't global editor permissions but, has in current scope in specified group", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				"*": {
+					Editor: false,
+				},
+				MyScope: {
+					Editor: true,
+				},
+			},
+		});
+
+		expect(
+			hasEditorPermissionsForScope,
+			"when called with",
+			["MyScope", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+					navigation: {
+						route: { location: {}, match: { params: { scope: "MyScope" } } },
+					},
+					settings: { defaultScope: "Global" },
+				}),
+			],
+			"to equal",
+			true,
+		);
+	});
+
+	it("Retrieves true if user has editor permissions just in specified scope", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				MyScope: {
+					Editor: true,
+				},
+			},
+		});
+
+		expect(
+			hasEditorPermissionsForScope,
+			"when called with",
+			["MyScope", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+					navigation: {
+						route: { location: {}, match: { params: { scope: "MyScope" } } },
+					},
+					settings: { defaultScope: "Global" },
+				}),
+			],
+			"to equal",
+			true,
+		);
+	});
+
+	it("Retrieves true if user has editor permissions just in specified scope with permission on parents", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				MyScope: {
+					Editor: true,
+				},
+			},
+		});
+
+		expect(
+			hasEditorPermissionsForScope,
+			"when called with",
+			["ChildScope", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+					...state,
+					navigation: {
+						route: { location: {}, match: { params: { scope: "ChildScope" } } },
+					},
+				}),
+			],
+			"to equal",
+			true,
+		);
+	});
+
+	it("Retrieves false if app roles claims are null", () => {
+		expect(
+			hasEditorPermissionsForScope,
+			"when called with",
+			["Global", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: {} },
+					navigation: {
+						route: { location: {}, match: { params: { scope: "Global" } } },
+					},
+					settings: { defaultScope: "Global" },
+				}),
+			],
+			"to equal",
+			false,
+		);
+	});
+});
+
 describe("hasAdministratorPermissions", () => {
 	it("Retrieves true if user has global administrator permissions in specified group", () => {
 		const claims = Immutable.fromJS({
@@ -279,10 +501,7 @@ describe("hasAdministratorPermissions", () => {
 			[
 				Immutable.fromJS({
 					authentication: { rolesClaimsValues: claims },
-					navigation: {
-						route: { location: {}, match: { params: { scope: "Global" } } },
-					},
-					settings: { defaultScope: "Global" },
+					...state,
 				}),
 			],
 			"to equal",
@@ -349,6 +568,34 @@ describe("hasAdministratorPermissions", () => {
 		);
 	});
 
+	it("Retrieves true if user has administrator permissions just in specified scope with permission on parents", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				MyScope: {
+					Administrator: true,
+				},
+			},
+		});
+
+		expect(
+			hasAdministratorPermissions,
+			"when called with",
+			["Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+					...state,
+					navigation: {
+						route: { location: {}, match: { params: { scope: "ChildScope" } } },
+					},
+				}),
+			],
+			"to equal",
+			true,
+		);
+	});
+
 	it("Retrieves false if app roles claims are null", () => {
 		expect(
 			hasAdministratorPermissions,
@@ -370,6 +617,164 @@ describe("hasAdministratorPermissions", () => {
 	});
 });
 
+describe("hasAdministratorPermissionsForScope", () => {
+	it("Retrieves true if user has administrator permissions in specified group", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				"*": {
+					Administrator: true,
+				},
+			},
+		});
+
+		expect(
+			hasAdministratorPermissionsForScope,
+			"when called with",
+			["Global", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+				}),
+			],
+			"to equal",
+			true,
+		);
+	});
+
+	it("Retrieves false if user has not administrator permissions in specified group", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				"*": {
+					Administrator: false,
+				},
+			},
+		});
+
+		expect(
+			hasAdministratorPermissionsForScope,
+			"when called with",
+			["Global", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+					...state,
+				}),
+			],
+			"to equal",
+			false,
+		);
+	});
+
+	it("Retrieves true if user hasn't global administrator permissions but, has in current scope in specified group", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				"*": {
+					Administrator: false,
+				},
+				MyScope: {
+					Administrator: true,
+				},
+			},
+		});
+
+		expect(
+			hasAdministratorPermissionsForScope,
+			"when called with",
+			["MyScope", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+					navigation: {
+						route: { location: {}, match: { params: { scope: "MyScope" } } },
+					},
+					settings: { defaultScope: "Global" },
+				}),
+			],
+			"to equal",
+			true,
+		);
+	});
+
+	it("Retrieves true if user has administrator permissions just in specified scope", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				MyScope: {
+					Administrator: true,
+				},
+			},
+		});
+
+		expect(
+			hasAdministratorPermissionsForScope,
+			"when called with",
+			["MyScope", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+					navigation: {
+						route: { location: {}, match: { params: { scope: "MyScope" } } },
+					},
+					settings: { defaultScope: "Global" },
+				}),
+			],
+			"to equal",
+			true,
+		);
+	});
+
+	it("Retrieves true if user has administrator permissions just in specified scope with permission on parents", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				MyScope: {
+					Administrator: true,
+				},
+			},
+		});
+
+		expect(
+			hasAdministratorPermissionsForScope,
+			"when called with",
+			["ChildScope", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+					...state,
+					navigation: {
+						route: { location: {}, match: { params: { scope: "ChildScope" } } },
+					},
+				}),
+			],
+			"to equal",
+			true,
+		);
+	});
+
+	it("Retrieves false if app roles claims are null", () => {
+		expect(
+			hasAdministratorPermissionsForScope,
+			"when called with",
+			["Global", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: {} },
+					navigation: {
+						route: { location: {}, match: { params: { scope: "Global" } } },
+					},
+					settings: { defaultScope: "Global" },
+				}),
+			],
+			"to equal",
+			false,
+		);
+	});
+});
+
 describe("hasReaderPermissions", () => {
 	it("Retrieves true if user has reader permissions in specified group", () => {
 		const claims = Immutable.fromJS({
@@ -416,10 +821,7 @@ describe("hasReaderPermissions", () => {
 			[
 				Immutable.fromJS({
 					authentication: { rolesClaimsValues: claims },
-					navigation: {
-						route: { location: {}, match: { params: { scope: "Global" } } },
-					},
-					settings: { defaultScope: "Global" },
+					...state,
 				}),
 			],
 			"to equal",
@@ -486,6 +888,34 @@ describe("hasReaderPermissions", () => {
 		);
 	});
 
+	it("Retrieves true if user has reader permissions just in specified scope with permission on parents", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				MyScope: {
+					Reader: true,
+				},
+			},
+		});
+
+		expect(
+			hasReaderPermissions,
+			"when called with",
+			["Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+					...state,
+					navigation: {
+						route: { location: {}, match: { params: { scope: "ChildScope" } } },
+					},
+				}),
+			],
+			"to equal",
+			true,
+		);
+	});
+
 	it("Retrieves false if app roles claims are null", () => {
 		expect(
 			hasReaderPermissions,
@@ -506,3 +936,161 @@ describe("hasReaderPermissions", () => {
 		);
 	});
 });
+
+describe("hasReaderPermissionsForScope", () => {
+	it("Retrieves true if user has administrator permissions in specified group", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				"*": {
+					Reader: true,
+				},
+			},
+		});
+
+		expect(
+			hasReaderPermissionsForScope,
+			"when called with",
+			["Global", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+				}),
+			],
+			"to equal",
+			true,
+		);
+	});
+
+	it("Retrieves false if user has not administrator permissions in specified group", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				"*": {
+					Reader: false,
+				},
+			},
+		});
+
+		expect(
+			hasReaderPermissionsForScope,
+			"when called with",
+			["Global", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+					...state,
+				}),
+			],
+			"to equal",
+			false,
+		);
+	});
+
+	it("Retrieves true if user hasn't global administrator permissions but, has in current scope in specified group", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				"*": {
+					Reader: false,
+				},
+				MyScope: {
+					Reader: true,
+				},
+			},
+		});
+
+		expect(
+			hasReaderPermissionsForScope,
+			"when called with",
+			["MyScope", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+					navigation: {
+						route: { location: {}, match: { params: { scope: "MyScope" } } },
+					},
+					settings: { defaultScope: "Global" },
+				}),
+			],
+			"to equal",
+			true,
+		);
+	});
+
+	it("Retrieves true if user has administrator permissions just in specified scope", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				MyScope: {
+					Reader: true,
+				},
+			},
+		});
+
+		expect(
+			hasReaderPermissionsForScope,
+			"when called with",
+			["MyScope", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+					navigation: {
+						route: { location: {}, match: { params: { scope: "MyScope" } } },
+					},
+					settings: { defaultScope: "Global" },
+				}),
+			],
+			"to equal",
+			true,
+		);
+	});
+
+	it("Retrieves true if user has administrator permissions just in specified scope with permission on parents", () => {
+		const claims = Immutable.fromJS({
+			Orders: {
+				MyScope: {
+					Reader: true,
+				},
+			},
+		});
+
+		expect(
+			hasReaderPermissionsForScope,
+			"when called with",
+			["ChildScope", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: claims },
+					...state,
+					navigation: {
+						route: { location: {}, match: { params: { scope: "ChildScope" } } },
+					},
+				}),
+			],
+			"to equal",
+			true,
+		);
+	});
+
+	it("Retrieves false if app roles claims are null", () => {
+		expect(
+			hasReaderPermissionsForScope,
+			"when called with",
+			["Global", "Orders"],
+			"called with",
+			[
+				Immutable.fromJS({
+					authentication: { rolesClaimsValues: {} },
+					navigation: {
+						route: { location: {}, match: { params: { scope: "Global" } } },
+					},
+					settings: { defaultScope: "Global" },
+				}),
+			],
+			"to equal",
+			false,
+		);
+	});
+});

package/src/selectors/modules.js

@@ -3,3 +3,10 @@ import { createSelector } from "reselect";
 const modulesData = state => state.get("modules");
 
 export const modulesSelector = createSelector(modulesData, data => data.getIn(["tree"]));
+
+export const getScopeModuleInformationSelector = createSelector(modulesData, data => {
+	return {
+		visibleModules: data.getIn(["visibleModules"]).toJS(),
+		...data.getIn(["lastScopeAndModuleSelection"]).toJS(),
+	};
+});

package/src/selectors/modules.test.js

@@ -1,5 +1,5 @@
 import Immutable from "immutable";
-import { modulesSelector } from "./modules";
+import { getScopeModuleInformationSelector, modulesSelector } from "./modules";
 
 describe("modulesSelector", () => {
 	let state;
@@ -7,6 +7,12 @@ describe("modulesSelector", () => {
 		state = Immutable.fromJS({
 			modules: {
 				tree: "modulesTree",
+				visibleModules: ["a", "module123"],
+				lastScopeAndModuleSelection: {
+					scope: "Norway",
+					moduleName: "Profiles",
+					routingPerformed: false,
+				},
 			},
 		});
 	});
@@ -14,4 +20,13 @@ describe("modulesSelector", () => {
 	it("Retrieves modules", () => {
 		expect(modulesSelector, "when called with", [state], "to equal", "modulesTree");
 	});
+
+	it("Retrieves modules and scope information", () => {
+		expect(getScopeModuleInformationSelector, "when called with", [state], "to equal", {
+			visibleModules: ["a", "module123"],
+			scope: "Norway",
+			moduleName: "Profiles",
+			routingPerformed: false,
+		});
+	});
 });

package/src/selectors/scope.js

@@ -13,6 +13,8 @@ import { getLocalization } from "../utils/localizationHelper";
 
 const scopeData = state => state.get("scopes");
 
+export const getScopesSelector = createSelector(scopeData, scopes => scopes);
+
 const localizedScopesSelector = createSelector(scopeData, currentLocaleOrDefault, (scopes, locale) =>
 	scopes.map(scope =>
 		scope.withMutations(s => {