orc-shared 1.6.0-dev.1 → 1.6.0-dev.10

package/src/hooks/useDispatchWithErrorHandling.test.js

@@ -0,0 +1,230 @@
+import React from "react";
+import { useDispatchWithErrorHandling } from "./useDispatchWithErrorHandling";
+import sinon from "sinon";
+import { mount } from "enzyme";
+import { Provider } from "react-redux";
+import Immutable from "immutable";
+import { pushGlobalErrorMessage } from "../actions/globalErrorMessages";
+
+const delay = () => new Promise(resolve => setTimeout(resolve, 10));
+
+describe("useDispatchWithErrorHandling", () => {
+	let store, state, dispatchSpy;
+
+	beforeEach(() => {
+		state = Immutable.fromJS({});
+		dispatchSpy = sinon.stub().named("dispatch");
+
+		store = {
+			subscribe: () => {},
+			dispatch: dispatchSpy,
+			getState: () => state,
+		};
+	});
+
+	it("Dispatches action just with specified parameters", () => {
+		dispatchSpy.resolves({});
+
+		const TestComp = () => {
+			const dispatch = useDispatchWithErrorHandling();
+			dispatch({
+				action: { type: "testing" },
+				errorTitle: "title",
+				errorDescription: "desc",
+				validationLookupModule: "order",
+				validationLookupName: "ValidationsOrderReturns",
+			});
+			return null;
+		};
+
+		const component = (
+			<Provider store={store}>
+				<TestComp />
+			</Provider>
+		);
+
+		mount(component);
+
+		expect(dispatchSpy.callCount, "to be", 1);
+		expect(dispatchSpy, "to have a call satisfying", { args: [{ type: "testing" }] });
+	});
+
+	it("does not push messages because data is null", () => {
+		dispatchSpy.resolves(null);
+
+		const TestComp = () => {
+			const dispatch = useDispatchWithErrorHandling();
+			dispatch({
+				action: { type: "testing" },
+				errorTitle: "title",
+				errorDescription: "desc",
+				validationLookupModule: "order",
+				validationLookupName: "ValidationsOrderReturns",
+			});
+			return null;
+		};
+
+		const component = (
+			<Provider store={store}>
+				<TestComp />
+			</Provider>
+		);
+
+		mount(component);
+
+		expect(dispatchSpy.callCount, "to be", 1);
+	});
+
+	it("does not push messages because data is an empty object", () => {
+		dispatchSpy.resolves({});
+
+		const TestComp = () => {
+			const dispatch = useDispatchWithErrorHandling();
+			dispatch({
+				action: { type: "testing" },
+				errorTitle: "title",
+				errorDescription: "desc",
+				validationLookupModule: "order",
+				validationLookupName: "ValidationsOrderReturns",
+			});
+			return null;
+		};
+
+		const component = (
+			<Provider store={store}>
+				<TestComp />
+			</Provider>
+		);
+
+		mount(component);
+
+		expect(dispatchSpy.callCount, "to be", 1);
+	});
+
+	it("does not push messages because data is a response with error=false", () => {
+		dispatchSpy.resolves({ error: false });
+
+		const TestComp = () => {
+			const dispatch = useDispatchWithErrorHandling();
+			dispatch({
+				action: { type: "testing" },
+				errorTitle: "title",
+				errorDescription: "desc",
+				validationLookupModule: "order",
+				validationLookupName: "ValidationsOrderReturns",
+			});
+			return null;
+		};
+
+		const component = (
+			<Provider store={store}>
+				<TestComp />
+			</Provider>
+		);
+
+		mount(component);
+
+		expect(dispatchSpy.callCount, "to be", 1);
+	});
+
+	it("dispatch new message with title and description because of empty msg list", () => {
+		dispatchSpy.resolves({
+			error: true,
+			payload: {
+				status: 500,
+			},
+		});
+
+		const TestComp = () => {
+			const dispatch = useDispatchWithErrorHandling();
+			dispatch({
+				action: { type: "testing" },
+				errorTitle: "title",
+				errorDescription: "desc",
+				validationLookupModule: "order",
+				validationLookupName: "ValidationsOrderReturns",
+			});
+			return null;
+		};
+
+		const component = (
+			<Provider store={store}>
+				<TestComp />
+			</Provider>
+		);
+
+		mount(component);
+
+		delay().then(() => {
+			expect(dispatchSpy.callCount, "to be", 2);
+			expect(dispatchSpy, "to have a call satisfying", {
+				args: [
+					pushGlobalErrorMessage({
+						title: "title",
+						description: "desc",
+						messages: [],
+					}),
+				],
+			});
+		});
+	});
+
+	it("dispatch new message with only title because msg list is filled", () => {
+		dispatchSpy.resolves({
+			error: true,
+			payload: {
+				status: 500,
+				response: {
+					errors: [
+						{
+							message: "msg",
+							lookupModule: "mod",
+							lookupName: "name",
+							lookupKey: "key",
+						},
+					],
+				},
+			},
+		});
+
+		const TestComp = () => {
+			const dispatch = useDispatchWithErrorHandling();
+			dispatch({
+				action: { type: "testing" },
+				errorTitle: "title",
+				errorDescription: "desc",
+				validationLookupModule: "order",
+				validationLookupName: "ValidationsOrderReturns",
+			});
+			return null;
+		};
+
+		const component = (
+			<Provider store={store}>
+				<TestComp />
+			</Provider>
+		);
+
+		mount(component);
+
+		delay().then(() => {
+			expect(dispatchSpy.callCount, "to be", 2);
+			expect(dispatchSpy, "to have a call satisfying", {
+				args: [
+					pushGlobalErrorMessage({
+						title: "title",
+						description: null,
+						messages: [
+							{
+								message: "msg",
+								lookupModule: "mod",
+								lookupName: "name",
+								lookupKey: "key",
+							},
+						],
+					}),
+				],
+			});
+		});
+	});
+});

package/src/reducers/globalErrorMessages.js

@@ -0,0 +1,25 @@
+import Immutable from "immutable";
+import { POP_GLOBAL_ERROR_MESSAGE, PUSH_GLOBAL_ERROR_MESSAGE } from "../actions/globalErrorMessages";
+
+const initialState = Immutable.fromJS({
+	dialog: {
+		errorMessages: [],
+	},
+});
+
+const globalErrorMessages = (state = initialState, action) => {
+	switch (action.type) {
+		case PUSH_GLOBAL_ERROR_MESSAGE: {
+			const newMsgs = state.getIn(["dialog", "errorMessages"]).push(Immutable.fromJS(action.payload));
+			return state.setIn(["dialog", "errorMessages"], newMsgs);
+		}
+		case POP_GLOBAL_ERROR_MESSAGE: {
+			const newMsgs = state.getIn(["dialog", "errorMessages"]).shift();
+			return state.setIn(["dialog", "errorMessages"], newMsgs);
+		}
+		default:
+			return state;
+	}
+};
+
+export default globalErrorMessages;

package/src/reducers/globalErrorMessages.test.js

@@ -0,0 +1,66 @@
+import Immutable from "immutable";
+import reducer from "./globalErrorMessages";
+import { popGlobalErrorMessage, pushGlobalErrorMessage } from "../actions/globalErrorMessages";
+
+describe("Global error messages reducer", () => {
+	it("behaves as a reducer should", () =>
+		expect(reducer, "to be a reducer with initial state", {
+			dialog: {
+				errorMessages: [],
+			},
+		}));
+
+	it("save new message to end of the list", () => {
+		const oldState = Immutable.fromJS({
+			dialog: {
+				errorMessages: [{ msg: "123" }],
+			},
+		});
+		const action = pushGlobalErrorMessage({ msg: "456" });
+		const newState = reducer(oldState, action);
+		expect(newState, "not to be", oldState).and(
+			"to equal",
+			Immutable.fromJS({
+				dialog: {
+					errorMessages: [{ msg: "123" }, { msg: "456" }],
+				},
+			}),
+		);
+	});
+
+	it("remove oldest message", () => {
+		const oldState = Immutable.fromJS({
+			dialog: {
+				errorMessages: [{ msg: "123" }, { msg: "456" }],
+			},
+		});
+		const action = popGlobalErrorMessage();
+		const newState = reducer(oldState, action);
+		expect(newState, "not to be", oldState).and(
+			"to equal",
+			Immutable.fromJS({
+				dialog: {
+					errorMessages: [{ msg: "456" }],
+				},
+			}),
+		);
+	});
+
+	it("remove oldest message on an empty list", () => {
+		const oldState = Immutable.fromJS({
+			dialog: {
+				errorMessages: [],
+			},
+		});
+		const action = popGlobalErrorMessage();
+		const newState = reducer(oldState, action);
+		expect(newState, "to be", oldState).and(
+			"to equal",
+			Immutable.fromJS({
+				dialog: {
+					errorMessages: [],
+				},
+			}),
+		);
+	});
+});

package/src/reducers/request.js

@@ -24,7 +24,8 @@ const requestReducer = (state = initialState, action) => {
 	}
 	if (action.type.endsWith("_FAILURE")) {
 		const requestName = action.type.replace(/_FAILURE$/, "");
-		if (safeGet(action, "payload", "status") === 403) {
+		const status = safeGet(action, "payload", "status");
+		if (status === 403 || status === 401) {
 			return state.deleteIn(["actives", requestName]).set("logout", true);
 		} else {
 			return state.deleteIn(["actives", requestName]).set("error", Immutable.fromJS(action));

package/src/reducers/request.test.js

@@ -125,4 +125,27 @@ describe("Request reducer", () => {
 			}),
 		);
 	});
+
+	it("clears activity flag and sets login flag when a request fails with status 401", () => {
+		const oldState = Immutable.fromJS({
+			actives: {
+				SOME_FLAG: true,
+				TEST_THIS: true,
+			},
+		});
+		const action = {
+			type: "TEST_THIS_FAILURE",
+			payload: { status: 401, message: "UnauthorizedAccessException" },
+		};
+		const newState = reducer(oldState, action);
+		expect(newState, "not to be", oldState).and(
+			"to equal",
+			Immutable.fromJS({
+				actives: {
+					SOME_FLAG: true,
+				},
+				[LOGOUT]: true,
+			}),
+		);
+	});
 });

package/src/reducers/scopes.js

@@ -10,6 +10,9 @@ const scopeReducer = (state = initialState, action) => {
 		case GET_SCOPES_SUCCESS: {
 			const loadedScopes = state.toJS();
 			const normalizedScopes = normalize(action.payload, scopeSchema);
+			if (action.meta && action.meta.reset) {
+				return Immutable.fromJS(normalizedScopes.entities.scopes);
+			}
 
 			if (Object.keys(loadedScopes).length > 0) {
 				const addedScope = {};

package/src/reducers/scopes.test.js

@@ -91,4 +91,51 @@ describe("scopes", () => {
 			}),
 		);
 	});
+
+	it("reset option should override previous state", () => {
+		const oldState = Immutable.Map({
+			Global: {
+				id: "Global",
+				isAuthorizedScope: true,
+				children: ["Child1", "Child2", "Child3"],
+				scopePath: ["Global"],
+			},
+			Child1: { id: "Child1", isAuthorizedScope: true, scopePath: ["Global", "Child1"], children: [] },
+			Child2: { id: "Child2", isAuthorizedScope: false, scopePath: ["Global", "Child2"], children: [] },
+			ChildOld: { id: "ChildOld", isAuthorizedScope: false, scopePath: ["Global", "ChildOld"], children: [] },
+		});
+
+		const action = {
+			type: GET_SCOPES_SUCCESS,
+			payload: {
+				id: "Global",
+				isAuthorizedScope: true,
+				children: [
+					{ id: "Child1", isAuthorizedScope: false, children: [], parentScopeId: "Global" },
+					{ id: "Child2", isAuthorizedScope: true, children: [], parentScopeId: "Global" },
+					{ id: "Child3", isAuthorizedScope: false, children: [], parentScopeId: "Global" },
+					{ id: "Child4", isAuthorizedScope: true, children: [], parentScopeId: "Global" },
+				],
+			},
+			meta: {
+				reset: true,
+			},
+		};
+		const newState = reducer(oldState, action);
+		return expect(newState, "not to be", oldState).and(
+			"to satisfy",
+			Immutable.fromJS({
+				Global: {
+					id: "Global",
+					isAuthorizedScope: true,
+					children: ["Child1", "Child2", "Child3", "Child4"],
+					scopePath: ["Global"],
+				},
+				Child1: { id: "Child1", isAuthorizedScope: false, scopePath: ["Global", "Child1"], children: [] },
+				Child2: { id: "Child2", isAuthorizedScope: true, scopePath: ["Global", "Child2"], children: [] },
+				Child3: { id: "Child3", isAuthorizedScope: false, scopePath: ["Global", "Child3"], children: [] },
+				Child4: { id: "Child4", isAuthorizedScope: true, scopePath: ["Global", "Child4"], children: [] },
+			}),
+		);
+	});
 });

package/src/selectors/globalErrorMessages.js

@@ -0,0 +1,11 @@
+import { createSelector } from "reselect";
+
+const globalMsgData = state => state.get("globalErrorMessages");
+
+export const firstDialogErrorMessageSelector = createSelector(globalMsgData, data => {
+	const msgs = data.getIn(["dialog", "errorMessages"]);
+	if (msgs.size === 0) {
+		return null;
+	}
+	return msgs.first().toJS();
+});

package/src/selectors/globalErrorMessages.test.js

@@ -0,0 +1,25 @@
+import Immutable from "immutable";
+import { firstDialogErrorMessageSelector } from "./globalErrorMessages";
+
+describe("firstDialogErrorMessageSelector", () => {
+	let state;
+	beforeEach(() => {
+		state = Immutable.fromJS({
+			globalErrorMessages: {
+				dialog: {
+					errorMessages: [{ msg: "123" }, { msg: "456" }],
+				},
+			},
+			view: {},
+		});
+	});
+
+	it("gets the first message", () => {
+		expect(firstDialogErrorMessageSelector, "called with", [state], "to satisfy", { msg: "123" });
+	});
+
+	it("gets the first message on an empty list", () => {
+		state = state.setIn(["globalErrorMessages", "dialog", "errorMessages"], Immutable.fromJS([]));
+		expect(firstDialogErrorMessageSelector, "called with", [state], "to satisfy", null);
+	});
+});

package/src/selectors/metadata.js

@@ -30,7 +30,7 @@ export const mappedLookupsListSelector = memoize(moduleName =>
 );
 
 const lookupValuesSelector = memoize((moduleName, lookupName) =>
-	createSelector(lookups, lookups => lookups.getIn([moduleName, "index", lookupName]) || Immutable.Map()),
+	createSelector(lookups, lookups => lookups.getIn([moduleName.toLowerCase(), "index", lookupName]) || Immutable.Map()),
 );
 
 export const lookupByNameSelector = memoize((moduleName, lookupName) =>

package/src/selectors/metadata.test.js

@@ -394,6 +394,18 @@ describe("namedLookupValuesSelector", () => {
 			"Annulla per motivo 1",
 		);
 	});
+
+	it("retrieves localized values with an uppercase module", () => {
+		expect(
+			namedLookupLocalizedSelector,
+			"when called with",
+			["ORDER", "CanceledStatusReasons", "CanceledReason1"],
+			"when called with",
+			[state],
+			"to satisfy",
+			"Annulla per motivo 1",
+		);
+	});
 });
 
 describe("selectCurrentLookupDetails", () => {

package/src/utils/buildUrl.js

@@ -21,7 +21,7 @@ export const loadConfig = () =>
 		.catch(() => {
 			console.warn("Failed to load config.json, falling back to dev defaults");
 			return {
-				serviceApiUrl: "https://orc-dev-ocs-cm.develop.orckestra.cloud:443/api",
+				serviceApiUrl: "https://occ-dev-ocs-cm.develop.orckestra.cloud:443/api",
 			};
 		})
 		.then(config => {

package/src/utils/responseProcessingHelper.js

@@ -0,0 +1,42 @@
+export const extractStandardErrorMessagesFromResponse = (response, validationLookupModule, validationLookupName) => {
+	let hasErrors = false;
+	const messages = [];
+
+	if (response?.error) {
+		hasErrors = true;
+
+		if (response.payload?.status === 422) {
+			if (response.payload?.response?.failures) {
+				// uses structure from our .Net ValidationFailuresExceptionHandler
+				response.payload.response.failures.forEach(failure => {
+					if (failure.errorCode) {
+						messages.push({
+							message: failure.errorMessage,
+							lookupModule: validationLookupModule,
+							lookupName: validationLookupName,
+							lookupKey: failure.errorCode,
+						});
+					}
+				});
+			}
+		} else if (response.payload?.status === 500) {
+			if (response.payload?.response?.errors) {
+				// uses structure from our .Net OrckestraExceptionErrorHandler
+				response.payload.response.errors.forEach(err => {
+					messages.push({
+						message: err.message,
+						lookupModule: err.lookupModule,
+						lookupName: err.lookupName,
+						lookupKey: err.lookupKey,
+						lookupReplacementValues: err.lookupReplacementValues,
+					});
+				});
+			}
+		}
+	}
+
+	return {
+		hasErrors,
+		messages,
+	};
+};