orc-shared 1.1.0-dev.8 → 1.1.1

package/src/reducers/requestStates.test.js

@@ -0,0 +1,399 @@
+import Immutable from "immutable";
+import reducer from "./requestStates";
+import { requestStateOperationMap, requestStateOperations } from "../constants";
+import { RESET_REQUEST_STATE } from "../actions/requestState";
+
+const defaultState = {
+	creates: Immutable.Map(),
+	deletes: Immutable.Map(),
+	fetches: Immutable.Map(),
+	updates: Immutable.Map(),
+};
+
+describe("Request reducer", () => {
+	it("behaves as a reducer should", () => expect(reducer, "to be a reducer with initial state", defaultState));
+
+	it("should do nothing for an unknown action with requestState", () => {
+		const oldState = Immutable.fromJS(defaultState);
+		const action = { type: "SOME_UNKNOWN_ACTION", meta: { requestState: {} } };
+		const newState = reducer(oldState, action);
+		expect(newState, "to be", oldState);
+	});
+
+	it("state should not be modified if the action does not have the correct state", () =>
+		expect(reducer, "to be a reducer with initial state", defaultState));
+
+	it("state should not be modified if the action does not have the correct state", () => {
+		const oldState = Immutable.fromJS(defaultState);
+		const action = { type: "TEST_THIS_REQUEST", meta: { requestState: null } };
+		const newState = reducer(oldState, action);
+		expect(newState, "to be", oldState);
+	});
+
+	it.each([
+		[requestStateOperations.delete, "REQUEST"],
+		[requestStateOperations.delete, "SUCCESS"],
+		[requestStateOperations.delete, "FAILURE"],
+		[requestStateOperations.update, "REQUEST"],
+		[requestStateOperations.update, "SUCCESS"],
+		[requestStateOperations.update, "FAILURE"],
+	])("%s %s should not modify the state if the operation is not supported", (operation, requestSuffix) => {
+		const oldState = Immutable.fromJS(defaultState);
+		const action = {
+			type: "TEST_THIS_" + requestSuffix,
+			meta: {
+				requestState: {
+					keys: ["key1", "key2"],
+					operation: "unsupported",
+				},
+			},
+		};
+		const newState = reducer(oldState, action);
+		expect(newState, "to be", oldState);
+	});
+
+	it.each([[requestStateOperations.delete], [requestStateOperations.update], [requestStateOperations.create]])(
+		"%s operation REQUEST should initialize the state for the specified keys",
+		operation => {
+			const oldState = Immutable.fromJS(defaultState);
+			const action = {
+				type: "TEST_THIS_REQUEST",
+				meta: {
+					requestState: {
+						keys: ["key1", "key2"],
+						operation: operation,
+					},
+				},
+			};
+
+			const expectedState = oldState.set(
+				requestStateOperationMap[operation],
+				Immutable.fromJS({
+					key1: {
+						key2: {
+							state: {
+								inProgress: true,
+								value: false,
+								error: false,
+								errorResponse: null,
+							},
+						},
+					},
+				}),
+			);
+
+			const newState = reducer(oldState, action);
+			expect(newState, "not to be", oldState).and("to equal", expectedState);
+		},
+	);
+
+	it.each([[requestStateOperations.delete], [requestStateOperations.update], [requestStateOperations.create]])(
+		"%s operation SUCCESS should initialize the state for the specified keys",
+		operation => {
+			const oldState = Immutable.fromJS(defaultState);
+			const action = {
+				type: "TEST_THIS_SUCCESS",
+				meta: {
+					requestState: {
+						keys: ["key1", "key2"],
+						operation: operation,
+					},
+				},
+			};
+
+			const expectedState = oldState.set(
+				requestStateOperationMap[operation],
+				Immutable.fromJS({
+					key1: {
+						key2: {
+							state: {
+								inProgress: false,
+								value: true,
+								error: false,
+								errorResponse: null,
+							},
+						},
+					},
+				}),
+			);
+
+			const newState = reducer(oldState, action);
+			expect(newState, "not to be", oldState).and("to equal", expectedState);
+		},
+	);
+
+	it.each([[requestStateOperations.delete], [requestStateOperations.update], [requestStateOperations.create]])(
+		"%s operation FAILURE should initialize the state for the specified keys",
+		operation => {
+			const oldState = Immutable.fromJS(defaultState);
+			const action = {
+				type: "TEST_THIS_FAILURE",
+				meta: {
+					requestState: {
+						keys: ["key1", "key2"],
+						operation: operation,
+					},
+				},
+			};
+
+			const expectedState = oldState.set(
+				requestStateOperationMap[operation],
+				Immutable.fromJS({
+					key1: {
+						key2: {
+							state: {
+								inProgress: false,
+								value: false,
+								error: true,
+								errorResponse: null,
+							},
+						},
+					},
+				}),
+			);
+
+			const newState = reducer(oldState, action);
+			expect(newState, "not to be", oldState).and("to equal", expectedState);
+		},
+	);
+
+	it.each([[requestStateOperations.delete], [requestStateOperations.update], [requestStateOperations.create]])(
+		"%s operation FAILURE with a response should initialize the state for the specified keys",
+		operation => {
+			const oldState = Immutable.fromJS(defaultState);
+
+			const action = {
+				type: "TEST_THIS_FAILURE",
+				payload: {
+					response: {
+						responseStatus: {
+							message: "a message",
+						},
+					},
+				},
+				meta: {
+					requestState: {
+						keys: ["key1", "key2"],
+						operation: operation,
+					},
+				},
+			};
+
+			const expectedState = oldState.set(
+				requestStateOperationMap[operation],
+				Immutable.fromJS({
+					key1: {
+						key2: {
+							state: {
+								inProgress: false,
+								value: false,
+								error: true,
+								errorResponse: action.payload,
+							},
+						},
+					},
+				}),
+			);
+
+			const newState = reducer(oldState, action);
+			expect(newState, "not to be", oldState).and("to equal", expectedState);
+		},
+	);
+
+	it.each([[requestStateOperations.delete], [requestStateOperations.update], [requestStateOperations.create]])(
+		"%s operation should accept a string as key",
+		operation => {
+			const oldState = Immutable.fromJS(defaultState);
+			const action = {
+				type: "TEST_THIS_REQUEST",
+				meta: {
+					requestState: {
+						keys: "key1",
+						operation: operation,
+					},
+				},
+			};
+
+			const expectedState = oldState.set(
+				requestStateOperationMap[operation],
+				Immutable.fromJS({
+					key1: {
+						state: {
+							inProgress: true,
+							value: false,
+							error: false,
+							errorResponse: null,
+						},
+					},
+				}),
+			);
+
+			const newState = reducer(oldState, action);
+			expect(newState, "not to be", oldState).and("to equal", expectedState);
+		},
+	);
+});
+
+describe("RESET_REQUEST_STATE", () => {
+	it("state should not be modified if the operation is not supported", () => {
+		const oldState = Immutable.fromJS(defaultState);
+		const action = {
+			type: RESET_REQUEST_STATE,
+			meta: {
+				requestState: {
+					keys: ["key1", "key2"],
+					operation: "unsupported",
+				},
+			},
+		};
+		const newState = reducer(oldState, action);
+		expect(newState, "to be", oldState);
+	});
+
+	it.each([[requestStateOperations.delete], [requestStateOperations.update], [requestStateOperations.create]])(
+		"state is initialized when empty for %s operation",
+		operation => {
+			const oldState = Immutable.fromJS(defaultState);
+			const action = {
+				type: RESET_REQUEST_STATE,
+				meta: {
+					requestState: {
+						keys: ["key1", "key2"],
+						operation: operation,
+					},
+				},
+			};
+
+			const expectedState = oldState.set(
+				requestStateOperationMap[operation],
+				Immutable.fromJS({
+					key1: {
+						key2: {
+							state: {
+								inProgress: false,
+								value: false,
+								error: false,
+								errorResponse: null,
+							},
+						},
+					},
+				}),
+			);
+
+			const newState = reducer(oldState, action);
+			expect(newState, "not to be", oldState).and("to equal", expectedState);
+		},
+	);
+
+	it.each([[requestStateOperations.delete], [requestStateOperations.update], [requestStateOperations.create]])(
+		"state is initialized when not empty for %s operation",
+		operation => {
+			let oldState = Immutable.fromJS(defaultState);
+			const action = {
+				type: RESET_REQUEST_STATE,
+				meta: {
+					requestState: {
+						keys: ["key1", "key2"],
+						operation: operation,
+					},
+				},
+			};
+
+			oldState = oldState.set(
+				requestStateOperationMap[operation],
+				Immutable.fromJS({
+					key1: {
+						key2: {
+							state: {
+								inProgress: true,
+								value: true,
+								error: true,
+								errorResponse: null,
+								anotherProp: true,
+							},
+						},
+					},
+				}),
+			);
+
+			const expectedState = oldState.set(
+				requestStateOperationMap[operation],
+				Immutable.fromJS({
+					key1: {
+						key2: {
+							state: {
+								inProgress: false,
+								value: false,
+								error: false,
+								errorResponse: null,
+							},
+						},
+					},
+				}),
+			);
+
+			const newState = reducer(oldState, action);
+			expect(newState, "not to be", oldState).and("to equal", expectedState);
+		},
+	);
+
+	it.each([[requestStateOperations.delete], [requestStateOperations.update], [requestStateOperations.create]])(
+		"other keys are not touched when state is initialized for %s operation",
+		operation => {
+			let oldState = Immutable.fromJS({
+				deletes: Immutable.Map({
+					key3: {
+						key4: {
+							state: {
+								inProgress: false,
+								value: true,
+								error: false,
+								errorResponse: null,
+							},
+						},
+					},
+				}),
+				updates: Immutable.Map({
+					key3: {
+						key4: {
+							state: {
+								inProgress: false,
+								value: true,
+								error: false,
+								errorResponse: null,
+							},
+						},
+					},
+				}),
+			});
+			const action = {
+				type: RESET_REQUEST_STATE,
+				meta: {
+					requestState: {
+						keys: ["key1", "key2"],
+						operation: operation,
+					},
+				},
+			};
+
+			const expectedState = oldState.mergeIn(
+				[requestStateOperationMap[operation]],
+				Immutable.fromJS({
+					key1: {
+						key2: {
+							state: {
+								inProgress: false,
+								value: false,
+								error: false,
+								errorResponse: null,
+							},
+						},
+					},
+				}),
+			);
+
+			const newState = reducer(oldState, action);
+			expect(newState, "not to be", oldState).and("to equal", expectedState);
+		},
+	);
+});

package/src/selectors/authentication.js

@@ -36,7 +36,6 @@ export const hasAdministratorPermissions = roleGroup =>
 export const hasReaderPermissions = roleGroup =>
 	createSelector(selectGroupRolesClaims(roleGroup), getCurrentScope, (appRolesClaims, currentScope) => {
 		if (appRolesClaims != null) {
-			console.log("appRolesClaims", appRolesClaims);
 			return (
 				!!appRolesClaims.getIn(["*", platformRoles.Reader]) ||
 				!!appRolesClaims.getIn([currentScope, platformRoles.Reader])

package/src/selectors/locale.test.js

@@ -217,7 +217,6 @@ describe("cultureOptionList", () => {
 				supportedLocales: [
 					{ language: "English", cultureIso: "en" },
 					{ language: "Français", cultureIso: "fr" },
-					{ language: "Italiano", cultureIso: "it" },
 				],
 			},
 		});
@@ -232,7 +231,6 @@ describe("cultureOptionList", () => {
 			Immutable.List([
 				{ value: "en", label: "English" },
 				{ value: "fr", label: "Français" },
-				{ value: "it", label: "Italiano" },
 			]),
 		));
 

package/src/selectors/metadata.js

@@ -5,8 +5,8 @@ import { setTranslationWithFallbackField } from "../utils/setTranslationWithFall
 import { currentLocaleOrDefault } from "../selectors/locale";
 import { getLocalization } from "../utils/localizationHelper";
 import { getPropertyOrDefault } from "../utils/propertyHelper";
-import { ORDER_LOOKUP_MODULE_NAME } from "../reducers/metadata";
-import { attributeDataType } from "../constants";
+import { ORDER_MODULE_NAME } from "../reducers/metadata";
+import { attributeDataType, definitionType } from "../constants";
 import { each, camelCase } from "lodash";
 
 const metadata = state => state.get("metadata");
@@ -19,10 +19,24 @@ export const lookupSelector = memoize(moduleName =>
 	createSelector(lookupsModule(moduleName), module => module.get("index")),
 );
 
+export const mappedLookupsListSelector = memoize(moduleName =>
+	createSelector(lookupSelector(moduleName), currentLocaleOrDefault, (lookups, locale) =>
+		lookups.map(lookup =>
+			lookup
+				.set("displayName", getLocalization(lookup.get("displayName"), locale, lookup.get("lookupName")))
+				.delete("values"),
+		),
+	),
+);
+
 const lookupValuesSelector = memoize((moduleName, lookupName) =>
 	createSelector(lookups, lookups => lookups.getIn([moduleName, "index", lookupName]) || Immutable.Map()),
 );
 
+export const lookupByNameSelector = memoize((moduleName, lookupName) =>
+	createSelector(lookups, lookups => lookups.getIn([moduleName, "index", lookupName]) || null),
+);
+
 export const namedLookupSelector = memoize((moduleName, lookupName) =>
 	createSelector(
 		lookupSelector(moduleName),
@@ -32,12 +46,16 @@ 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"),
+		),
 	),
 );
 
-export const selectCurrentLookupDetails = memoize((moduleName, id) => namedLookupSelector(moduleName, id));
+export const selectCurrentLookupDetails = memoize((moduleName, lookupName) =>
+	namedLookupSelector(moduleName, lookupName),
+);
 
 export const namedLookupLocalizedSelector = memoize((moduleName, lookupName, key, defaultValue = key) =>
 	createSelector(lookupValuesSelector(moduleName, lookupName), currentLocaleOrDefault, (lookups, locale) => {
@@ -80,23 +98,55 @@ export const mappedLookupListSelector = memoize(moduleName =>
 	),
 );
 
-export const orderLookupsListCurrentInfo = lookupsListCurrentInfo(ORDER_LOOKUP_MODULE_NAME);
+export const orderLookupsListCurrentInfo = lookupsListCurrentInfo(ORDER_MODULE_NAME);
 
-export const orderLookupsNextPageToLoad = lookupsNextPageToLoad(ORDER_LOOKUP_MODULE_NAME);
+export const orderLookupsNextPageToLoad = lookupsNextPageToLoad(ORDER_MODULE_NAME);
 
-export const mappedOrderLookupsListSelector = mappedLookupListSelector(ORDER_LOOKUP_MODULE_NAME);
+export const mappedOrderLookupsListSelector = mappedLookupListSelector(ORDER_MODULE_NAME);
 
 /***  DEFINITIONS  ***/
 const definitions = createSelector(metadata, meta => meta.get("definitions"));
 const definitionsModule = memoize(moduleName =>
-	createSelector(definitions, definitions => definitions.get(moduleName)),
+	createSelector(definitions, definitions => definitions.get(moduleName) ?? Immutable.Map()),
+);
+
+export const mappedDefinitionsListSelector = memoize(moduleName =>
+	createSelector(definitionsModule(moduleName), currentLocaleOrDefault, (definitions, locale) =>
+		definitions.map(definition =>
+			definition
+				.set("type", definition.get("isSharedEntity") === true ? definitionType.shared : definitionType.embedded)
+				.set("displayName", getLocalization(definition.get("displayName"), locale, definition.get("entityTypeName")))
+				.delete("attributes"),
+		),
+	),
+);
+
+export const mappedCustomDefinitionsListSelector = memoize(moduleName =>
+	createSelector(mappedDefinitionsListSelector(moduleName), definitions =>
+		definitions.filter(a => a.get("isBuiltIn") === false),
+	),
 );
 
-const definitionEntity = memoize((moduleName, entityName) =>
+export const mappedBaseDefinitionsListSelector = memoize(moduleName =>
+	createSelector(mappedDefinitionsListSelector(moduleName), definitions =>
+		definitions.filter(a => a.get("isBuiltIn") === true),
+	),
+);
+
+export const newProfileDefinitionInstanceSelector = createSelector(
+	definitions,
+	definitions => definitions.get("newInstance") || null,
+);
+
+export const newProfileDefinitionNameSelector = createSelector(definitions, definitions =>
+	definitions.get("newInstanceId"),
+);
+
+export const definitionEntity = memoize((moduleName, entityName) =>
 	createSelector(definitionsModule(moduleName), definition => definition.getIn([entityName]) || Immutable.Map()),
 );
 
-const mappedDefinitionEntity = memoize((moduleName, entityName) =>
+export const mappedDefinitionEntity = memoize((moduleName, entityName) =>
 	createSelector(definitionEntity(moduleName, entityName), currentLocaleOrDefault, (definition, locale) =>
 		setTranslationWithFallbackField(locale, definition, "entityTypeName", "displayName"),
 	),
@@ -109,16 +159,29 @@ const definitionEntityAttributes = memoize((moduleName, entityName) =>
 	),
 );
 
-const mappedDefinitionAttributesSelector = memoize((moduleName, entityName) =>
+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)),
+);
+
+export const definitionEntityBaseAttributesSelector = memoize((moduleName, entityName) =>
+	createSelector(definitionEntityAttributes(moduleName, entityName), filterIsBuiltInAttributes(true)),
+);
+
+export const mappedDefinitionAttributesSelector = memoize((moduleName, entityName) =>
 	createSelector(definitionEntityAttributes(moduleName, entityName), currentLocaleOrDefault, (attributes, locale) =>
 		attributes.map(a => setTranslationWithFallbackField(locale, a, "name", "displayName")),
 	),
 );
 
 export const customAttributesSelector = memoize((moduleName, entityName) =>
-	createSelector(mappedDefinitionAttributesSelector(moduleName, entityName), attributes =>
-		attributes.filter(a => a.get("isBuiltIn") === false),
-	),
+	createSelector(mappedDefinitionAttributesSelector(moduleName, entityName), filterIsBuiltInAttributes(false)),
+);
+
+export const baseAttributesSelector = memoize((moduleName, entityName) =>
+	createSelector(mappedDefinitionAttributesSelector(moduleName, entityName), filterIsBuiltInAttributes(true)),
 );
 
 export const profileAttributeGroupsSelector = createSelector(metadata, currentLocaleOrDefault, (meta, locale) => {
@@ -144,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")),
@@ -160,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);
 		},
 	),