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

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

@@ -1,5 +1,6 @@
 import { allValue } from "../constants";
 import { memoize } from "./index";
+import { getNotLocalizedString } from "./localizationHelper";
 
 export const getValueWithAll = value => {
 	if (!value) return allValue;
@@ -20,9 +21,10 @@ export const extractDropboxOptionsMemo = (data, config = undefined) => {
 	let options = [];
 	items.forEach(v => {
 		if (!activeKey || v.get(activeKey)) {
+			const value = v.get(valueKey);
 			options.push({
-				value: v.get(valueKey),
-				label: v.get(labelKey) || (fallbackLabelKey && v.get(fallbackLabelKey)),
+				value: value,
+				label: v.get(labelKey) || (fallbackLabelKey && v.get(fallbackLabelKey)) || getNotLocalizedString(value),
 				sortOrder: v.get(sortOrderKey),
 			});
 		}

package/src/utils/filterHelper.test.js

@@ -43,8 +43,8 @@ describe("extractDropboxOptions", () => {
 		const result = extractDropboxOptions(lookup);
 
 		expect(result, "to equal", [
-			{ value: "value1", label: undefined, sortOrder: 0 },
-			{ value: "value3", label: undefined, sortOrder: 3 },
+			{ value: "value1", label: "[value1]", sortOrder: 0 },
+			{ value: "value3", label: "[value3]", sortOrder: 3 },
 		]);
 	});
 
@@ -60,8 +60,8 @@ describe("extractDropboxOptions", () => {
 		const result = extractDropboxOptions(lookups);
 
 		expect(result, "to equal", [
-			{ value: "value4", label: undefined, sortOrder: 0 },
-			{ value: "value6", label: undefined, sortOrder: 3 },
+			{ value: "value4", label: "[value4]", sortOrder: 0 },
+			{ value: "value6", label: "[value6]", sortOrder: 3 },
 		]);
 	});
 
@@ -77,8 +77,8 @@ describe("extractDropboxOptions", () => {
 		const result = extractDropboxOptions(lookup);
 
 		expect(result, "to equal", [
-			{ value: "value1", label: undefined, sortOrder: 0 },
-			{ value: "value3", label: undefined, sortOrder: 3 },
+			{ value: "value1", label: "[value1]", sortOrder: 0 },
+			{ value: "value3", label: "[value3]", sortOrder: 3 },
 		]);
 	});
 

package/src/utils/inputHelper.js

@@ -0,0 +1,6 @@
+export const trimSpacesAndLeadingZeros = (value, fallback = "") => {
+	const trimmed = (value ?? "").trim().replace(/^0+/, "");
+	return trimmed === "" ? fallback : limitNumericValueLength(trimmed);
+};
+
+export const limitNumericValueLength = (value, maximum = 9) => value.substring(0, maximum);

package/src/utils/inputHelper.test.js

@@ -0,0 +1,31 @@
+import { limitNumericValueLength, trimSpacesAndLeadingZeros } from "./inputHelper";
+
+describe("Numeric Input Helper", () => {
+	it("trimSpacesAndLeadingZeros trims spaces and leading zeros", () => {
+		expect(trimSpacesAndLeadingZeros, "when called with", ["  00013 "], "to equal", "13");
+	});
+
+	it("trimSpacesAndLeadingZeros trims spaces and leading zeros returning fallback value", () => {
+		expect(trimSpacesAndLeadingZeros, "when called with", [" 000  ", "def"], "to equal", "def");
+	});
+
+	it("trimSpacesAndLeadingZeros should work on floating values", () => {
+		expect(trimSpacesAndLeadingZeros, "when called with", ["042.2", "def"], "to equal", "42.2");
+	});
+
+	it("trimSpacesAndLeadingZeros returns fallback on null value", () => {
+		expect(trimSpacesAndLeadingZeros, "when called with", [null, "def"], "to equal", "def");
+	});
+
+	it("trimSpacesAndLeadingZeros returns fallback on undefined value", () => {
+		expect(trimSpacesAndLeadingZeros, "when called with", [undefined, "def"], "to equal", "def");
+	});
+
+	it("limitNumericValueLength trims extra characters", () => {
+		expect(limitNumericValueLength, "when called with", ["01234567890"], "to equal", "012345678");
+	});
+
+	it("limitNumericValueLength trims extra characters with another maximum", () => {
+		expect(limitNumericValueLength, "when called with", ["01234567890", 5], "to equal", "01234");
+	});
+});

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,

package/src/utils/testUtils.test.js

@@ -187,7 +187,7 @@ describe("PropStruct", () => {
 				<dt>num:</dt>
 				<dd>number 1</dd>
 				<dt>str:</dt>
-				<dd>string "foo"</dd>
+				<dd>string &quot;foo&quot;</dd>
 			</dl>,
 		));
 
@@ -198,7 +198,7 @@ describe("PropStruct", () => {
 			"to satisfy",
 			<dl id="testProps">
 				<dt>id:</dt>
-				<dd>string "testProps"</dd>
+				<dd>string &quot;testProps&quot;</dd>
 			</dl>,
 		));
 
@@ -261,7 +261,7 @@ describe("PropStruct", () => {
 					<div id="tc2" />
 				</dd>
 				<dt>foo:</dt>
-				<dd>string "bar"</dd>
+				<dd>string &quot;bar&quot;</dd>
 			</dl>,
 		));
 
@@ -275,7 +275,7 @@ describe("PropStruct", () => {
 				<dd>
 					<dl>
 						<dt>bar:</dt>
-						<dd>string "false"</dd>
+						<dd>string &quot;false&quot;</dd>
 						<dt>foo:</dt>
 						<dd>boolean true</dd>
 					</dl>