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

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/metadata.js

@@ -46,8 +46,10 @@ export const namedLookupSelector = memoize((moduleName, lookupName) =>
 );
 
 export const namedLookupValuesSelector = memoize((moduleName, lookupName) =>
-	createSelector(namedLookupSelector(moduleName, lookupName), currentLocaleOrDefault, (statuses, locale) =>
-		(statuses.get("values") || Immutable.Map()).map(status => setTranslation(locale, status, "displayName")),
+	createSelector(namedLookupSelector(moduleName, lookupName), currentLocaleOrDefault, (lookup, locale) =>
+		(lookup.get("values") || Immutable.Map()).map(lookupValue =>
+			setTranslationWithFallbackField(locale, lookupValue, "name", "displayName"),
+		),
 	),
 );
 
@@ -157,7 +159,8 @@ const definitionEntityAttributes = memoize((moduleName, entityName) =>
 	),
 );
 
-const filterIsBuiltInAttributes = isBuiltIn => attributes => attributes.filter(a => a.get("isBuiltIn") === isBuiltIn);
+const filterIsBuiltInAttributes = isBuiltIn => attributes =>
+	attributes.filter(a => a.get("isBuiltIn") === isBuiltIn).sortBy(x => x.get("displayOrder"));
 
 export const definitionEntityCustomAttributesSelector = memoize((moduleName, entityName) =>
 	createSelector(definitionEntityAttributes(moduleName, entityName), filterIsBuiltInAttributes(false)),
@@ -204,11 +207,15 @@ export const groupedCustomAttributesDefinitionSelector = memoize((moduleName, en
 					})
 						.set(
 							"baseAttributes",
-							group.filter(i => i.get("dataType") !== attributeDataType.entityReference),
+							group
+								.filter(i => i.get("dataType") !== attributeDataType.entityReference)
+								.sortBy(x => x.get("displayOrder")),
 						)
 						.set(
 							"profileAttributes",
-							group.filter(i => i.get("dataType") === attributeDataType.entityReference),
+							group
+								.filter(i => i.get("dataType") === attributeDataType.entityReference)
+								.sortBy(x => x.get("displayOrder")),
 						);
 				})
 				.sortBy(x => x.get("displayOrder")),
@@ -220,8 +227,12 @@ export const customAttributesDefinitionSelector = memoize((moduleName, profileEn
 		mappedDefinitionEntity(moduleName, profileEntityName),
 		customAttributesSelector(moduleName, profileEntityName),
 		(definition, attributes) => {
-			const profileAttributes = attributes?.filter(a => a.get("dataType") === attributeDataType.entityReference);
-			const baseAttributes = attributes?.filter(a => a.get("dataType") !== attributeDataType.entityReference);
+			const profileAttributes = attributes
+				?.filter(a => a.get("dataType") === attributeDataType.entityReference)
+				.sortBy(x => x.get("displayOrder"));
+			const baseAttributes = attributes
+				?.filter(a => a.get("dataType") !== attributeDataType.entityReference)
+				.sortBy(x => x.get("displayOrder"));
 			return definition.set("baseAttributes", baseAttributes).set("profileAttributes", profileAttributes);
 		},
 	),