orc-shared 5.7.0-dev.9 → 5.8.0-dev.2

package/src/components/MaterialUI/Inputs/PredefinedElements/SearchControl.test.js

@@ -238,6 +238,63 @@ describe("SearchControl Component", () => {
 		expect(onSearchEvent, "to have calls satisfying", [{ args: ["aValue", "abc"] }]);
 	});
 
+	it("Search value should be trimmed after a search", () => {
+		const options = [
+			{ value: "aValue", label: "aLabel" },
+			{ value: "anotherValue", label: "anotherLabel" },
+		];
+
+		const onSearchEvent = sinon.spy().named("search");
+
+		const component = (
+			<TestWrapper stylesProvider muiThemeProvider={{ theme }}>
+				<SearchControl placeholder="placeHolderTest" searchOptions={options} onSearch={onSearchEvent} />
+			</TestWrapper>
+		);
+
+		const mountedComponent = mount(component);
+
+		const allInputs = mountedComponent.find("input");
+		const searchInput = allInputs.find("[placeholder='placeHolderTest']");
+		expect(searchInput.length, "to be", 1);
+
+		searchInput.instance().value = "abc ";
+		mountedComponent.find("form").simulate("submit", { preventDefault: () => {} });
+
+		expect(onSearchEvent, "to have calls satisfying", [{ args: ["aValue", "abc"] }]);
+	});
+
+	it("Search value should not be trimmed after a search", () => {
+		const options = [
+			{ value: "aValue", label: "aLabel" },
+			{ value: "anotherValue", label: "anotherLabel" },
+		];
+
+		const onSearchEvent = sinon.spy().named("search");
+
+		const component = (
+			<TestWrapper stylesProvider muiThemeProvider={{ theme }}>
+				<SearchControl
+					placeholder="placeHolderTest"
+					searchOptions={options}
+					onSearch={onSearchEvent}
+					trimSearchvalue={false}
+				/>
+			</TestWrapper>
+		);
+
+		const mountedComponent = mount(component);
+
+		const allInputs = mountedComponent.find("input");
+		const searchInput = allInputs.find("[placeholder='placeHolderTest']");
+		expect(searchInput.length, "to be", 1);
+
+		searchInput.instance().value = "abc ";
+		mountedComponent.find("form").simulate("submit", { preventDefault: () => {} });
+
+		expect(onSearchEvent, "to have calls satisfying", [{ args: ["aValue", "abc "] }]);
+	});
+
 	it("Search Control should trigger the event when clicking on the search button", () => {
 		const options = [
 			{ value: "aValue", label: "aLabel" },

package/src/components/Provision.js

@@ -11,6 +11,7 @@ import Head from "./Head";
 import I18n from "./I18n";
 import InternetExplorerWarningMessage from "./InternetExplorerWarningMessage";
 import Culture from "./Culture";
+import ScopeExtendedConfigurationLoader from "./ScopeExtendedConfigurationLoader";
 
 const GlobalStyle = createGlobalStyle`
 	html {
@@ -53,6 +54,7 @@ const Provision = ({ store, theme = {}, muiTheme, children }) => {
 											<InternetExplorerWarningMessage />
 										</I18n>
 									</DevPages>
+									<ScopeExtendedConfigurationLoader />
 								</React.Fragment>
 							</Authenticate>
 						</React.Fragment>

package/src/components/Provision.test.js

@@ -54,6 +54,13 @@ const fakeStore = {
 				loadedModulesScope: ["moduleA", "moduleB"],
 				modules: ["moduleA", "moduleB"],
 			},
+			navigation: {
+				route: {
+					match: { path: "/:scope/TheModuleName/:entityId", params: { scope: "TheOldScope", entityId: "loaderId" } },
+				},
+				moduleTabs: {},
+				config: { prependPath: "/:scope/", prependHref: "/Scope1/" },
+			},
 		}),
 	replaceReducer: () => {},
 };

package/src/components/ScopeExtendedConfigurationLoader.js

@@ -0,0 +1,22 @@
+import { useEffect, useState } from "react";
+import useScopeData from "./Scope/useScopeData";
+import { useDispatch } from "react-redux";
+import { getScopeExtendedConfiguration } from "../actions/scopes";
+
+const ScopeExtendedConfigurationLoader = () => {
+	const [currentScope] = useScopeData();
+	const dispatch = useDispatch();
+
+	const [localScopeValue, setLocalScopeValue] = useState();
+
+	useEffect(() => {
+		if (currentScope.id !== localScopeValue) {
+			setLocalScopeValue(currentScope.id);
+			dispatch(getScopeExtendedConfiguration(currentScope.id));
+		}
+	}, [currentScope.id, dispatch, localScopeValue]);
+
+	return null;
+};
+
+export default ScopeExtendedConfigurationLoader;

package/src/components/ScopeExtendedConfigurationLoader.test.js

@@ -0,0 +1,71 @@
+import React from "react";
+import Immutable from "immutable";
+import { Provider } from "react-redux";
+import { ThemeProvider } from "styled-components";
+import ScopeExtendedConfigurationLoader from "./ScopeExtendedConfigurationLoader";
+import { mount } from "enzyme";
+import { getScopeExtendedConfiguration } from "../actions/scopes";
+import sinon from "sinon";
+
+jest.mock("../utils/buildUrl", () => {
+	const modExport = {};
+	modExport.loadConfig = () => Promise.resolve({});
+	modExport.buildUrl = (path = [], params = "") => "URL: " + path.join("/") + " " + JSON.stringify(params);
+	return modExport;
+});
+
+describe("ScopeExtendedConfigurationLoader", () => {
+	let state, store;
+
+	beforeEach(() => {
+		state = Immutable.fromJS({
+			locale: {
+				locale: "en-US",
+			},
+			authentication: {
+				name: "foo@bar.com",
+			},
+			requests: {},
+			scopes: {
+				TheOldScope: {
+					id: "TheOldScope",
+					name: { "en-CA": "Test 1", "en-US": "TheOldScope" },
+					children: ["test2"],
+				},
+			},
+			settings: {
+				defaultScope: "aDefaultScope",
+				loadedModulesScope: ["moduleA", "moduleB"],
+				modules: ["moduleA", "moduleB"],
+			},
+			navigation: {
+				route: {
+					match: { path: "/:scope/TheModuleName/:entityId", params: { scope: "TheOldScope", entityId: "loaderId" } },
+				},
+				moduleTabs: {},
+				config: { prependPath: "/:scope/", prependHref: "/Scope1/" },
+			},
+		});
+		store = state => ({
+			subscribe: () => {},
+			getState: () => state,
+			dispatch: sinon.spy().named("dispatch"),
+		});
+	});
+
+	it("dispatch request to get extended configuration", () => {
+		const theStore = store(state);
+
+		const component = (
+			<Provider store={theStore}>
+				<ThemeProvider theme={{}}>
+					<ScopeExtendedConfigurationLoader />
+				</ThemeProvider>
+			</Provider>
+		);
+
+		mount(component);
+
+		expect(theStore.dispatch, "to have calls satisfying", [{ args: [getScopeExtendedConfiguration("TheOldScope")] }]);
+	});
+});

package/src/constants.js

@@ -74,6 +74,8 @@ export const attributeDataType = {
 	lookup: "Lookup",
 	entityReference: "EntityReference",
 	customType: "CustomType",
+	singleChoice: "SingleChoice",
+	multipleChoice: "MultipleChoice",
 };
 
 // It is intended that some of them have a different value of its keys
@@ -166,7 +168,13 @@ export const jsonCargoType = {
 	double: "Double",
 	dateTime: "DateTime",
 	integer: "Int32",
+	stringArray: "String[]",
 	entityReferences: "Guid[]",
 };
 
 export const allValue = "#All#";
+
+export const choiceControlOrientation = {
+	horizontal: "Horizontal",
+	vertical: "Vertical",
+};

package/src/content/icons/orckestra-icon.svg

@@ -1,5 +1,11 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="260" height="260" viewBox="0 0 260 260">
-	<path d="M1.11,125.62C1.11,74.94,40.22,39,93.72,39S186,74.94,186,125.62s-38.79,86.66-92.29,86.66S1.11,176.3,1.11,125.62Zm135.47,0c0-29.1-18.46-46.62-42.86-46.62S50.54,96.52,50.54,125.62s18.77,46.62,43.18,46.62S136.58,154.72,136.58,125.62Z" fill="#000000"/>
-	<circle id="ac06531b-599d-4b05-a30e-b1c94e55ddff" data-name="fullLogo" cx="227.6" cy="181.13" r="31.29" fill="#000000" opacity="0.33"/>
-	<circle id="af2ef0cf-5c47-4a93-b3be-f4e8ec48b016" data-name="fullLogo" cx="227.6" cy="181.13" r="31.29" fill="#e00600"/>
-</svg>
+<svg width="354" height="354" viewBox="0 0 354 354" fill="none" xmlns="http://www.w3.org/2000/svg">
+	<g clip-path="url(#clip0_2_1387)">
+		<path d="M0 241.41C0 175.92 50.53 129.43 119.66 129.43C188.79 129.43 238.91 175.92 238.91 241.41C238.91 306.9 188.78 353.38 119.66 353.38C50.54 353.38 0 306.9 0 241.41ZM175.04 241.41C175.04 203.81 151.19 181.18 119.66 181.18C88.13 181.18 63.87 203.82 63.87 241.41C63.87 279 88.13 301.64 119.66 301.64C151.19 301.64 175.04 279 175.04 241.41Z" fill="black"/>
+		<path d="M353.14 165.06H275.66C275.66 116.77 236.37 77.48 188.08 77.48V0C279.1 0 353.15 74.05 353.15 165.06H353.14Z" fill="#E00600"/>
+	</g>
+	<defs>
+		<clipPath id="clip0_2_1387">
+			<rect width="353.14" height="353.38" fill="white"/>
+		</clipPath>
+	</defs>
+</svg>

package/src/reducers/scopesExtendedConfiguration.js

@@ -0,0 +1,16 @@
+import Immutable from "immutable";
+import { GET_SCOPE_EXTENDED_CONFIGURATION_SUCCESS } from "../actions/scopes";
+
+const initialState = Immutable.fromJS({});
+
+const scopesExtendedConfigurationReducer = (state = initialState, action) => {
+	switch (action.type) {
+		case GET_SCOPE_EXTENDED_CONFIGURATION_SUCCESS: {
+			return state.set(action.meta.scope, Immutable.fromJS(action.payload));
+		}
+		default:
+			return state;
+	}
+};
+
+export default scopesExtendedConfigurationReducer;

package/src/reducers/scopesExtendedConfiguration.test.js

@@ -0,0 +1,31 @@
+import Immutable from "immutable";
+import { GET_SCOPE_EXTENDED_CONFIGURATION_SUCCESS } from "../actions/scopes";
+import reducer from "./scopesExtendedConfiguration";
+
+describe("scopesExtendedConfiguration", () => {
+	it("behaves as a reducer should", () => expect(reducer, "to be a reducer with initial state", {}));
+
+	it("save scope info to store", () => {
+		const oldState = Immutable.Map({
+			TheScope: { extConfig: 789 },
+			anotherScope: { extConfig: 456 },
+		});
+		const action = {
+			type: GET_SCOPE_EXTENDED_CONFIGURATION_SUCCESS,
+			meta: {
+				scope: "TheScope",
+			},
+			payload: {
+				extConfig: 123,
+			},
+		};
+		const newState = reducer(oldState, action);
+		return expect(newState, "not to be", oldState).and(
+			"to satisfy",
+			Immutable.fromJS({
+				TheScope: { extConfig: 123 },
+				anotherScope: { extConfig: 456 },
+			}),
+		);
+	});
+});

package/src/selectors/metadata.js

@@ -66,6 +66,15 @@ export const namedLookupLocalizedSelector = memoize((moduleName, lookupName, key
 	}),
 );
 
+export const lookupExistAndIsActiveSelector = memoize((moduleName, lookupName, key) =>
+	createSelector(lookupValuesSelector(moduleName, lookupName), lookups => {
+		const values = lookups.get("values");
+		if (values == null || key == null) return false;
+		const value = values.get(key);
+		return value?.get("isActive") === true;
+	}),
+);
+
 export const namedLookupLocalizedValuesSelector = memoize((moduleName, lookupName) =>
 	createSelector(lookupValuesSelector(moduleName, lookupName), currentLocaleOrDefault, (lookup, locale) =>
 		(lookup.get("values") || Immutable.Map()).map(lookupValue =>

package/src/selectors/metadata.test.js

@@ -30,6 +30,7 @@ import {
 	definitionEntityCustomAttributesSelector,
 	lookupByNameSelector,
 	mappedLookupsListSelector,
+	lookupExistAndIsActiveSelector,
 } from "./metadata";
 
 const lookups = {
@@ -1899,3 +1900,92 @@ describe("definitions", () => {
 		);
 	});
 });
+
+describe("lookupExistAndIsActiveSelector", () => {
+	let state;
+	beforeEach(() => {
+		state = Immutable.fromJS({
+			locale: { locale: "it-IT" },
+			metadata: {
+				lookups: {
+					order: {
+						index: {
+							...lookups,
+							DistanceUOM: {
+								lookupName: "DistanceUOM",
+								values: {
+									Inches: {
+										value: "Inches",
+										displayName: {
+											"en-CA": "inEnCa",
+											"en-US": "inEnUS",
+											"fr-CA": "inFrCa",
+											"it-IT": "inItIt",
+										},
+										isActive: true,
+									},
+								},
+							},
+						},
+						list: [],
+					},
+				},
+			},
+		});
+	});
+
+	it("retrieves true when lookup exist and value is active", () => {
+		expect(
+			lookupExistAndIsActiveSelector,
+			"when called with",
+			["order", "DistanceUOM", "Inches"],
+			"when called with",
+			[state],
+			"to be",
+			true,
+		);
+	});
+
+	it("retrieves false when lookup exist and value is inactive", () => {
+		state = state.setIn(
+			["metadata", "lookups", "order", "index", "DistanceUOM", "values", "Inches", "isActive"],
+			false,
+		);
+
+		expect(
+			lookupExistAndIsActiveSelector,
+			"when called with",
+			["order", "DistanceUOM", "Inches"],
+			"when called with",
+			[state],
+			"to be",
+			false,
+		);
+	});
+
+	it("retrieves false when lookup exist and its values property is null", () => {
+		state = state.setIn(["metadata", "lookups", "order", "index", "DistanceUOM", "values"], null);
+
+		expect(
+			lookupExistAndIsActiveSelector,
+			"when called with",
+			["order", "DistanceUOM", "Inches"],
+			"when called with",
+			[state],
+			"to be",
+			false,
+		);
+	});
+
+	it("retrieves false when lookup exist and lookup value name does not exist", () => {
+		expect(
+			lookupExistAndIsActiveSelector,
+			"when called with",
+			["order", "DistanceUOM", "unknown"],
+			"when called with",
+			[state],
+			"to be",
+			false,
+		);
+	});
+});

package/src/selectors/scopeExtendedConfiguration.js

@@ -0,0 +1,9 @@
+import { createSelector } from "reselect";
+
+const scopesExtendedConfigurationData = state => state.get("scopesExtendedConfiguration");
+
+export const doesScopeHaveGeolocationProviderSelector = scopeId => {
+	return createSelector(scopesExtendedConfigurationData, scopesCfg => {
+		return scopesCfg?.get(scopeId)?.get("hasGeolocationProvider") ?? false;
+	});
+};

package/src/selectors/scopeExtendedConfiguration.test.js

@@ -0,0 +1,45 @@
+import Immutable from "immutable";
+import { doesScopeHaveGeolocationProviderSelector } from "./scopeExtendedConfiguration";
+
+let state;
+beforeEach(() => {
+	state = Immutable.fromJS({
+		navigation: {
+			route: { location: {}, match: { params: { scope: "SecondChild" } } },
+		},
+		locale: {
+			locale: "fr",
+			supportedLocales: ["en", "fr"],
+		},
+		scopesExtendedConfiguration: {
+			theScope: { hasGeolocationProvider: true },
+		},
+		settings: {
+			defaultScope: "FirstChild",
+		},
+	});
+});
+
+describe("doesScopeHaveGeolocationProviderSelector", () => {
+	it("gets an unknown scope", () =>
+		expect(
+			doesScopeHaveGeolocationProviderSelector,
+			"when called with",
+			["Unknown"],
+			"called with",
+			[state],
+			"to be",
+			false,
+		));
+
+	it("gets a known scope", () =>
+		expect(
+			doesScopeHaveGeolocationProviderSelector,
+			"when called with",
+			["theScope"],
+			"called with",
+			[state],
+			"to be",
+			true,
+		));
+});

package/src/utils/propertyBagHelper.js

@@ -49,7 +49,10 @@ export const toJsonCargo = (attribute, value) => {
 	switch (attribute.dataType) {
 		case attributeDataType.text:
 		case attributeDataType.lookup:
+		case attributeDataType.singleChoice:
 			return value;
+		case attributeDataType.multipleChoice:
+			return createJsonCargo(jsonCargoType.stringArray, value);
 
 		case attributeDataType.boolean:
 			return createJsonCargo(jsonCargoType.boolean, value);

package/src/utils/propertyBagHelper.test.js

@@ -123,6 +123,13 @@ describe("toJsonCargo function", () => {
 				tiers: [{ min: "2", rate: "2" }],
 			},
 		],
+		["aRadioValue", attributeDataType.singleChoice, null, "aRadioValue"],
+		[
+			["aCheckboxValue1", "aCheckboxValue1"],
+			attributeDataType.multipleChoice,
+			null,
+			{ __type: "ValueOfString[]", value: ["aCheckboxValue1", "aCheckboxValue1"] },
+		],
 	])("should return the proper json cargo with %s of type %s", (value, dataType, customType, expectedCargo) => {
 		const attribute = {
 			dataType: dataType,