orc-shared 5.10.0-dev.2 → 5.10.0-dev.20

package/src/hooks/useMultipleFieldEditState.js

@@ -1,7 +1,7 @@
 import { useSelector } from "react-redux";
 import { validationRules } from "../utils/modelValidationHelper";
 import { getModifiedModels } from "../selectors/view";
-import { setEditModelField, setEditModelFieldError } from "../actions/view";
+import { setEditModelField, setEditModelFieldError, removeEditModelFieldError } from "../actions/view";
 import { useDispatchWithModulesData } from "./../hooks/useDispatchWithModulesData";
 
 /* This hook is used when a component has a dynamic number of fields that can be edited (e.g.: Orders' Custom Configuration Parameters).
@@ -25,7 +25,7 @@ const useMultipleFieldEditState = (entityId, sectionName, initialValues, extende
 	const mergedValidationRules = { ...validationRules, ...extendedValidationRules };
 	const modifiedStates = useSelector(getModifiedModels(entityId))[sectionName] || {};
 
-	const useDynamicFieldState = (id, fieldName, errorTypes = []) => {
+	const useDynamicFieldState = (id, fieldName, errorTypes = [], fieldDependencies = {}) => {
 		const keys = [id, fieldName];
 
 		const initialValue = initialValues[id]?.[fieldName] ?? "";
@@ -42,12 +42,15 @@ const useMultipleFieldEditState = (entityId, sectionName, initialValues, extende
 			dispatch(setEditModelField, [keys, initialValue, initialValue, entityId, sectionName]);
 		};
 
-		const isEditStateValid = value => {
+		const isEditStateValid = (value, dependencies = {}) => {
 			const valueToValidate = value ?? editState.value;
 
 			let hasAnyValidationErrors = false;
 			errorTypes.forEach(errorType => {
-				const isValid = mergedValidationRules[errorType](valueToValidate, id, fieldName);
+				const isValid = mergedValidationRules[errorType](valueToValidate, id, fieldName, {
+					...fieldDependencies,
+					...dependencies,
+				});
 
 				if (isValid === false) {
 					dispatch(setEditModelFieldError, [keys, errorType, entityId, sectionName]);
@@ -57,6 +60,10 @@ const useMultipleFieldEditState = (entityId, sectionName, initialValues, extende
 				}
 			});
 
+			if (!hasAnyValidationErrors) {
+				dispatch(removeEditModelFieldError, [keys, entityId, sectionName]);
+			}
+
 			return !hasAnyValidationErrors;
 		};
 

package/src/hooks/useMultipleFieldEditState.test.js

@@ -5,7 +5,7 @@ import Immutable from "immutable";
 import sinon from "sinon";
 import { mount } from "enzyme";
 import * as useDispatchWithModulesDataMock from "./useDispatchWithModulesData";
-import { setEditModelField, setEditModelFieldError } from "./../actions/view";
+import { removeEditModelFieldError, setEditModelField, setEditModelFieldError } from "./../actions/view";
 import { validationErrorTypes } from "./../constants";
 import _ from "lodash";
 
@@ -404,6 +404,54 @@ describe("useMultipleFieldEditState", () => {
 		}
 	});
 
+	it("Updates edit view value and reset error correctly with custom validation rules when validation was passed", () => {
+		const useDispatchWithModulesDataSpy = sinon.spy();
+		const useDispatchWithModulesDataStub = sinon
+			.stub(useDispatchWithModulesDataMock, "useDispatchWithModulesData")
+			.returns(useDispatchWithModulesDataSpy);
+
+		try {
+			// TODOJOC
+			const mountedComponent = mountComponent();
+
+			const fieldComponent = mountedComponent.find(`#id1-prop1-update`);
+
+			const event = {
+				target: {
+					value: "anotherValue",
+				},
+			};
+
+			fieldComponent.invoke("onClick")(event);
+
+			const resetEvent = {
+				target: {
+					value: "custom",
+				},
+			};
+
+			fieldComponent.invoke("onClick")(resetEvent);
+
+			const id = "id1";
+			const fieldName = "prop1";
+			const initialFieldValue = fieldInitialValues[id][fieldName];
+
+			expect(useDispatchWithModulesDataSpy, "to have a call satisfying", {
+				args: [setEditModelField, [[id, fieldName], "anotherValue", initialFieldValue, entityId, sectionName]],
+			});
+
+			expect(useDispatchWithModulesDataSpy, "to have a call satisfying", {
+				args: [setEditModelFieldError, [[id, fieldName], "customRule", entityId, sectionName]],
+			});
+
+			expect(useDispatchWithModulesDataSpy, "to have a call satisfying", {
+				args: [removeEditModelFieldError, [[id, fieldName], entityId, sectionName]],
+			});
+		} finally {
+			useDispatchWithModulesDataStub.restore();
+		}
+	});
+
 	it.each([
 		["id1", "prop1"],
 		["id1", "prop2"],

package/src/reducers/metadata.js

@@ -1,7 +1,7 @@
 import Immutable from "immutable";
 import { normalize } from "normalizr";
 import { definitionsListSchema } from "../schemas/definitions";
-import { profileAttributeGroupsListSchema } from "../schemas/metadata";
+import { orderAttributeGroupsListSchema, profileAttributeGroupsListSchema } from "../schemas/metadata";
 import { productDefinitionsListSchema } from "../schemas/productDefinitions";
 import {
 	GET_ORDER_LOOKUPS_SUCCESS,
@@ -26,6 +26,7 @@ import {
 	UPDATE_PROFILE_DEFINITION_SUCCESS,
 	GET_ORDER_LOOKUP_SUCCESS,
 	GET_CUSTOMER_LOOKUP_SUCCESS,
+	GET_ORDER_ATTRIBUTE_GROUPS_SUCCESS,
 } from "../actions/metadata";
 
 export const ORDER_MODULE_NAME = "order";
@@ -154,6 +155,10 @@ const metadataReducer = (state = initialState, action) => {
 			const normalizedData = normalize(action.payload?.profileAttributeGroups, profileAttributeGroupsListSchema);
 			return state.set("profileAttributeGroups", Immutable.fromJS(normalizedData.entities.metadata));
 		}
+		case GET_ORDER_ATTRIBUTE_GROUPS_SUCCESS: {
+			const normalizedData = normalize(action.payload?.orderAttributeGroups, orderAttributeGroupsListSchema);
+			return state.set("orderAttributeGroups", Immutable.fromJS(normalizedData.entities.metadata));
+		}
 		case SAVE_ORDER_LOOKUP_SUCCESS:
 		case GET_ORDER_LOOKUP_SUCCESS:
 			return lookupReducerHelper.getLookupsQuerySuccess(ORDER_MODULE_NAME, state, {

package/src/reducers/metadata.test.js

@@ -22,6 +22,7 @@ import {
 	ADD_CUSTOMER_LOOKUP_SUCCESS,
 	GET_ORDER_LOOKUP_SUCCESS,
 	GET_CUSTOMER_LOOKUP_SUCCESS,
+	GET_ORDER_ATTRIBUTE_GROUPS_SUCCESS,
 } from "../actions/metadata";
 import reducer from "./metadata";
 
@@ -1553,3 +1554,33 @@ describe("profileAttributeGroups", () => {
 		);
 	});
 });
+
+describe("orderAttributeGroups", () => {
+	it("saves orderAttributeGroups metadata", () => {
+		const orderAttributeGroupsPayload = {
+			displayOrder: 1,
+			name: "Default",
+			displayName: {
+				"en-US": "Default",
+				"fr-CA": "Défaut",
+			},
+			isSystem: false,
+		};
+		const oldState = Immutable.fromJS({
+			orderAttributeGroups: {},
+		});
+		const action = {
+			type: GET_ORDER_ATTRIBUTE_GROUPS_SUCCESS,
+			payload: { orderAttributeGroups: [orderAttributeGroupsPayload] },
+		};
+		const newState = reducer(oldState, action);
+		return expect(newState, "not to be", oldState).and(
+			"to equal",
+			Immutable.fromJS({
+				orderAttributeGroups: {
+					Default: orderAttributeGroupsPayload,
+				},
+			}),
+		);
+	});
+});

package/src/requests

@@ -8,6 +8,7 @@ getCountriesRequest
 getCustomerDefinitionsRequest
 getCustomerLookupRequest
 getCustomerLookupsRequest
+getOrderAttributeGroupsRequest
 getOrderDefinitionRequest
 getOrderLookupRequest
 getOrderLookupsRequest

package/src/schemas/metadata.js

@@ -3,3 +3,6 @@ import { schema } from "normalizr";
 export const profileAttributeGroupsSchema = new schema.Entity("metadata", {}, { idAttribute: "name" });
 export const profileAttributeGroupsListSchema = [profileAttributeGroupsSchema];
 export default profileAttributeGroupsListSchema;
+
+export const orderAttributeGroupsSchema = new schema.Entity("metadata", {}, { idAttribute: "name" });
+export const orderAttributeGroupsListSchema = [orderAttributeGroupsSchema];

package/src/selectors/locale.js

@@ -28,7 +28,7 @@ export const defaultCulture = createSelector(localeData, locale => locale.get("d
 export const orderedCultureList = createSelector(cultureList, defaultCulture, (cultures, defaultCulture) =>
 	cultures.sort((a, b) => {
 		/*istanbul ignore if */ if (a === defaultCulture) return -1;
-		if (b === defaultCulture) return 1;
+		/*istanbul ignore if */ if (b === defaultCulture) return 1;
 		return 0;
 	}),
 );

package/src/selectors/metadata.js

@@ -210,26 +210,29 @@ export const baseAttributesSelector = memoize((moduleName, entityName) =>
 	createSelector(mappedDefinitionAttributesSelector(moduleName, entityName), filterIsBuiltInAttributes(true)),
 );
 
-export const profileAttributeGroupsSelector = createSelector(metadata, currentLocaleOrDefault, (meta, locale) => {
-	const groups = meta.get("profileAttributeGroups");
-	return !groups?.size ? null : groups?.map(x => setTranslationWithFallbackField(locale, x, "name", "displayName"));
-});
+export const moduleAttributeGroupsSelector = memoize(moduleName =>
+	createSelector(metadata, currentLocaleOrDefault, (meta, locale) => {
+		const metaDataGroupName = moduleName === "order" ? "orderAttributeGroups" : "profileAttributeGroups";
+		const groups = meta.get(metaDataGroupName);
+		return !groups?.size ? null : groups?.map(x => setTranslationWithFallbackField(locale, x, "name", "displayName"));
+	}),
+);
 
 export const groupedCustomAttributesDefinitionSelector = memoize((moduleName, entityName) =>
 	createSelector(
-		profileAttributeGroupsSelector,
+		moduleAttributeGroupsSelector(moduleName),
 		customAttributesSelector(moduleName, entityName),
 		currentLocaleOrDefault,
-		(allProfileAttributeGroups, attributes) =>
+		(allAttributeGroups, attributes) =>
 			attributes
 				.groupBy(item => item.get("groupId"))
 				.map(group => {
 					const groupId = group.first().get("groupId");
-					const profileAttributeGroup = allProfileAttributeGroups?.get(groupId);
+					const attributeGroup = allAttributeGroups?.get(groupId);
 					return Immutable.fromJS({
 						id: groupId,
-						name: profileAttributeGroup?.get("displayName"),
-						displayOrder: profileAttributeGroup?.get("displayOrder"),
+						name: attributeGroup?.get("displayName"),
+						displayOrder: attributeGroup?.get("displayOrder"),
 					})
 						.set(
 							"baseAttributes",

package/src/selectors/metadata.test.js

@@ -18,7 +18,6 @@ import {
 	productPropertyValueSelector,
 	productPropertyValuesSelector,
 	variantPropertyKeyValuesSelector,
-	profileAttributeGroupsSelector,
 	selectCurrentLookupDetails,
 	mappedDefinitionsListSelector,
 	baseAttributesSelector,
@@ -1367,6 +1366,29 @@ describe("definitions", () => {
 							allowPriceLists: true,
 						},
 					},
+					order: {
+						ORDER: {
+							displayName: {
+								"en-CA": "Order",
+								"en-US": "Order",
+								"fr-CA": "ORDER",
+							},
+							entityTypeName: "CUSTOMER",
+							isBuiltIn: true,
+							attributes: [
+								baseBuitInAttribute1,
+								baseBuitInAttribute2,
+								customProfileAttribute1,
+								customProfileAttribute2,
+								baseBuitInAttribute4,
+								baseBuitInAttribute3,
+								baseCustomAttribute1,
+								baseCustomAttribute3,
+								baseCustomAttribute2,
+							],
+							isSharedEntity: true,
+						},
+					},
 				},
 				profileAttributeGroups: {
 					Default: {
@@ -1388,20 +1410,21 @@ describe("definitions", () => {
 						},
 					},
 				},
+				orderAttributeGroups: {
+					Default: {
+						displayOrder: 1,
+						name: "Default",
+						displayName: {
+							"en-US": "Default en-US",
+							"en-CA": "Default en-CA",
+							"fr-CA": "Default fr-CA",
+						},
+					},
+				},
 			},
 		});
 	});
 
-	it("will get null if profileAttributeGroups are not found in metadata", () => {
-		const newState = Immutable.fromJS({
-			locale: {},
-			metadata: {
-				profileAttributeGroups: {},
-			},
-		});
-		expect(profileAttributeGroupsSelector, "when called with", [newState], "to satisfy", null);
-	});
-
 	it("will return correct customer profile definition", () => {
 		const expected = Immutable.fromJS({
 			CustomProfile1: {
@@ -1591,6 +1614,64 @@ describe("definitions", () => {
 		);
 	});
 
+	it("will return correct custom order attributes definition in correct order", () => {
+		const expectedGroup1 = customProfileAttribute1.groupId;
+		const expectedItem1 = {
+			...customProfileAttribute1,
+			...{ displayName: customProfileAttribute1.displayName["en-US"] },
+		};
+
+		const expectedBaseCustomWithOrder1 = {
+			...baseCustomAttribute1,
+			...{ displayName: baseCustomAttribute1.displayName["en-US"] },
+		};
+
+		const expectedBaseCustomWithOrder2 = {
+			...baseCustomAttribute2,
+			...{ displayName: baseCustomAttribute2.displayName["en-US"] },
+		};
+
+		const expectedBaseCustomWithOrder3 = {
+			...baseCustomAttribute3,
+			...{ displayName: baseCustomAttribute3.displayName["en-US"] },
+		};
+
+		const expected = Immutable.fromJS({
+			[expectedGroup1]: {
+				id: expectedGroup1,
+				name: "Default en-US",
+				baseAttributes: [expectedBaseCustomWithOrder1, expectedBaseCustomWithOrder2, expectedBaseCustomWithOrder3],
+				profileAttributes: [expectedItem1],
+			},
+		});
+
+		expect(
+			groupedCustomAttributesDefinitionSelector,
+			"when called with",
+			["order", "ORDER"],
+			"when called with",
+			[state],
+			"to satisfy",
+			expected,
+		);
+	});
+
+	it("will return correct custom attributes definition in correct order for unknown module", () => {
+		const expected = Immutable.fromJS({});
+
+		const newState = state.removeIn(["metadata", "profileAttributeGroups"]);
+
+		expect(
+			groupedCustomAttributesDefinitionSelector,
+			"when called with",
+			["invalid", "invalid"],
+			"when called with",
+			[newState],
+			"to satisfy",
+			expected,
+		);
+	});
+
 	it("will return correct full base (built in) customer definition attributes", () => {
 		const expected = Immutable.fromJS([
 			baseBuitInAttribute1,

package/src/sharedMessages.js

@@ -299,6 +299,10 @@ const sharedMessages = defineMessages({
 		id: "orc-shared.lastModifiedBy",
 		defaultMessage: "Last Modified By",
 	},
+	search: {
+		id: "orc-shared.search",
+		defaultMessage: "Search",
+	},
 });
 
 export default sharedMessages;

package/src/translations/en-US.json

@@ -58,6 +58,7 @@
 	"orc-shared.scopeChangeWithUnsavedDataConfirmation": "One or more entities opened will be closed with unsaved data. Would you like to change scope?",
 	"orc-shared.scopeChangeWithUnsavedDataTitle": "Confirm scope change without saving data",
 	"orc-shared.scopeFilterPlaceholder": "Type a scope name",
+	"orc-shared.search": "Search",
 	"orc-shared.shared": "Shared",
 	"orc-shared.showFewerLanguages": "Show fewer languages",
 	"orc-shared.showMoreLanguages": "Show more languages",

package/src/translations/fr-CA.json

@@ -58,6 +58,7 @@
 	"orc-shared.scopeChangeWithUnsavedDataConfirmation": "Une ou plusieurs entités ouvertes seront fermées, entraînant la perte de données non-sauvegardées. Voulez-vous vraiment changer de Scope?",
 	"orc-shared.scopeChangeWithUnsavedDataTitle": "Confirmation du changement de Scope sans sauvegarde",
 	"orc-shared.scopeFilterPlaceholder": "Entrez un nom de Scope",
+	"orc-shared.search": "Recherche",
 	"orc-shared.shared": "Partagé",
 	"orc-shared.showFewerLanguages": "Afficher moins de langues",
 	"orc-shared.showMoreLanguages": "Afficher plus de langues",

package/src/utils/ListHelper.js

@@ -0,0 +1,203 @@
+import Immutable from "immutable";
+import { isObject } from "lodash";
+
+export const ListInfoPropertyName = "listInfo";
+
+const standardInfoKeys = ["scope", "page", "filters", "sorting", "totalCount", "nextPageToLoad", "index", "list"];
+
+class ListReducerHelper {
+	constructor(groupPropertyName) {
+		this.groupPropertyName = groupPropertyName;
+	}
+
+	setNextPageToLoad = (state, nextPageToLoad) => {
+		return state.setIn([this.groupPropertyName, "nextPageToLoad"], nextPageToLoad);
+	};
+
+	setResults = (state, listInfo, forceReset = false) => {
+		return state.withMutations(s => {
+			const page = s.getIn([this.groupPropertyName, "nextPageToLoad"]);
+
+			const entities = Immutable.fromJS(listInfo.indexEntities || {});
+			if (page === 1 || forceReset) {
+				s.setIn([this.groupPropertyName, "index"], entities);
+				s.setIn([this.groupPropertyName, "list"], Immutable.fromJS(listInfo.listEntities));
+			} else {
+				s.mergeIn([this.groupPropertyName, "index"], entities);
+				s.setIn(
+					[this.groupPropertyName, "list"],
+					s.getIn([this.groupPropertyName, "list"]).concat(Immutable.fromJS(listInfo.listEntities)),
+				);
+			}
+
+			s.setIn([this.groupPropertyName, "totalCount"], listInfo.totalCount);
+		});
+	};
+
+	setCurrentInfo = (state, { resetList, scope, filters, sorting, ...others } = {}) => {
+		return state.withMutations(s => {
+			if (resetList) {
+				s.setIn([this.groupPropertyName, "nextPageToLoad"], 1);
+				s.setIn([this.groupPropertyName, "page"], null);
+				s.setIn([this.groupPropertyName, "index"], Immutable.fromJS({}));
+				s.setIn([this.groupPropertyName, "list"], Immutable.fromJS([]));
+				s.setIn([this.groupPropertyName, "totalCount"], 0);
+			} else {
+				const nextPageToLoad = state.getIn([this.groupPropertyName, "nextPageToLoad"]);
+				s.setIn([this.groupPropertyName, "nextPageToLoad"], nextPageToLoad);
+				s.setIn([this.groupPropertyName, "page"], nextPageToLoad);
+			}
+
+			s.setIn([this.groupPropertyName, "scope"], scope ?? null);
+			s.setIn([this.groupPropertyName, "filters"], Immutable.fromJS(filters ?? null));
+			s.setIn([this.groupPropertyName, "sorting"], Immutable.fromJS(sorting ?? null));
+
+			const otherKeys = Object.keys(others);
+
+			s.get(this.groupPropertyName)
+				.keySeq()
+				.forEach(key => {
+					if (!standardInfoKeys.includes(key) && !otherKeys.includes(key)) {
+						s.removeIn([this.groupPropertyName, key]);
+					}
+				});
+
+			otherKeys.forEach(key => {
+				s.setIn([this.groupPropertyName, key], isObject(others[key]) ? Immutable.fromJS(others[key]) : others[key]);
+			});
+		});
+	};
+
+	addIndexWithMutations = (mutator, id, value) => {
+		mutator.setIn([this.groupPropertyName, "index", id], Immutable.fromJS(value));
+	};
+
+	appendIdToListWithMutations = (mutator, id) => {
+		mutator.setIn([this.groupPropertyName, "list"], mutator.getIn([this.groupPropertyName, "list"]).push(id));
+	};
+
+	updateIndexWithMutations = (mutator, id, value) => {
+		const key = [this.groupPropertyName, "index", id];
+		if (mutator.getIn(key)) {
+			mutator.setIn(key, Immutable.fromJS(value));
+		}
+	};
+
+	removeFromIndexWithMutations = (mutator, id) => {
+		mutator.removeIn([this.groupPropertyName, "index", id]);
+	};
+
+	resetListInfo = (state, propertiesToKeep = {}) => {
+		let updatedState = state
+			.setIn([this.groupPropertyName, "nextPageToLoad"], 1)
+			.setIn([this.groupPropertyName, "index"], Immutable.fromJS({}))
+			.setIn([this.groupPropertyName, "list"], Immutable.fromJS([]))
+			.setIn([this.groupPropertyName, "totalCount"], 0);
+
+		if (!propertiesToKeep.filters) {
+			updatedState = updatedState.setIn([this.groupPropertyName, "filters"], null);
+		}
+
+		if (!propertiesToKeep.sorting) {
+			updatedState = updatedState.setIn([this.groupPropertyName, "sorting"], null);
+		}
+
+		if (!propertiesToKeep.scope) {
+			updatedState = updatedState.setIn([this.groupPropertyName, "scope"], null);
+		}
+
+		if (!propertiesToKeep.page) {
+			updatedState = updatedState.setIn([this.groupPropertyName, "page"], null);
+		}
+
+		return updatedState;
+	};
+}
+
+class ListSelectorHelper {
+	constructor(groupPropertyName) {
+		this.groupPropertyName = groupPropertyName;
+	}
+
+	getCurrentInfo = state => {
+		const listInfo = state.get(this.groupPropertyName) || Immutable.Map();
+
+		const info = {
+			currentScope: listInfo.get("scope"),
+			currentPage: listInfo.get("page"),
+			currentFilters: listInfo.get("filters")?.toJS(),
+			currentSorting: listInfo.get("sorting")?.toJS(),
+			totalCount: listInfo.get("totalCount"),
+		};
+
+		listInfo.mapKeys((key, value) => {
+			if (standardInfoKeys.includes(key)) {
+				// standard key, nothing to do
+			} else {
+				info[key] = value?.toJS ? value.toJS() : value;
+			}
+		});
+
+		return info;
+	};
+
+	getIndex = state => {
+		return state.getIn([this.groupPropertyName, "index"]);
+	};
+
+	getList = state => {
+		return state.getIn([this.groupPropertyName, "list"]);
+	};
+
+	getNextPageToLoad = state => {
+		return state.getIn([this.groupPropertyName, "nextPageToLoad"]);
+	};
+}
+
+class ListHelper {
+	constructor(groupPropertyName = ListInfoPropertyName) {
+		this.groupPropertyName = groupPropertyName;
+		this.reducer = new ListReducerHelper(this.groupPropertyName);
+		this.selector = new ListSelectorHelper(this.groupPropertyName);
+	}
+
+	static defaultInstance = new ListHelper();
+	static reducer = ListHelper.defaultInstance.reducer;
+	static selector = ListHelper.defaultInstance.selector;
+	static createInitialListInfo = ListHelper.defaultInstance.createInitialListInfo;
+	static createListInfoFrom = ListHelper.defaultInstance.createListInfoFrom;
+
+	createInitialListInfo = (additionalValues = null) => {
+		return this.createListInfoFrom({
+			...additionalValues,
+		});
+	};
+
+	createListInfoFrom = ({
+		sorting,
+		filters,
+		scope,
+		page,
+		nextPageToLoad,
+		index,
+		list,
+		totalCount,
+		...additionalValues
+	} = {}) => {
+		return {
+			[this.groupPropertyName]: {
+				sorting: sorting ?? null,
+				filters: filters ?? null,
+				scope: scope ?? null,
+				page: page ?? null,
+				nextPageToLoad: nextPageToLoad ?? 1,
+				index: index ?? {},
+				list: list ?? [],
+				totalCount: totalCount ?? 0,
+				...additionalValues,
+			},
+		};
+	};
+}
+
+export default ListHelper;