@inseefr/lunatic 0.1.13-hackathon → 0.2.0-v2

package/src/use-lunatic/initial-state.js

@@ -0,0 +1,31 @@
+import { COLLECTED, VTL } from 'utils/constants';
+
+const INITIAL_STATE = {
+	variables: {}, // map des variables du questionnaires
+	pages: {},
+	isInLoop: false,
+	isFirstPage: false,
+	isLastPage: false,
+	features: [VTL],
+	preferences: [COLLECTED],
+	savingType: COLLECTED,
+	cleaning: {},
+	missingBlock: {},
+	resizing: {},
+	pager: {
+		page: undefined,
+		maxPage: undefined,
+		subPage: undefined,
+		nbSubPages: undefined,
+		iteration: undefined,
+		nbIterations: undefined,
+	},
+	waiting: false,
+	errors: undefined,
+	/* fonctionnalités vtl & md */
+	updateBindings: () => {},
+	executeExpression: () => {},
+	handleChange: () => {},
+};
+
+export default INITIAL_STATE;

package/src/use-lunatic/reducer/commons/index.js

@@ -0,0 +1,3 @@
+export { default as isOnEmptyPage } from './is-empty-on-empty-page';
+export { default as resizeArrayVariable } from './resize-array-variable';
+export { default as validateLoopConditionFilter } from './validate-loop-condition-filter';

package/src/use-lunatic/reducer/commons/is-empty-on-empty-page.js

@@ -0,0 +1,29 @@
+import { getComponentsFromState, executeConditionFilter } from '../../commons';
+
+function isOnEmptyPage(state) {
+	const { executeExpression, pager } = state;
+	const { iteration } = pager;
+	const components = getComponentsFromState(state);
+	const rest = components.reduce(function (rest, component) {
+		const { conditionFilter } = component;
+		if (conditionFilter) {
+			const result = executeConditionFilter(
+				conditionFilter,
+				executeExpression,
+				iteration
+			);
+			if (result === true) {
+				return [...rest, component];
+			}
+		}
+		return rest;
+	}, []);
+
+	if (!rest.length) {
+		return true;
+	}
+
+	return false;
+}
+
+export default isOnEmptyPage;

package/src/use-lunatic/reducer/commons/resize-array-variable.js

@@ -0,0 +1,26 @@
+/**
+ * certaines variables du questionnaire sont de type tableau.
+ * Il faut alors vérifier qu'elles le sont véritablement.
+ * Il faut aussi vérifier quelles sont de la taille adéquate.
+ * @param {*} array
+ * @param {*} length
+ * @returns le tableau à la taille correcte.
+ */
+function resizeArrayVariable(array, length) {
+	if (!Array.isArray(array)) {
+		// create the array
+		return new Array(length).fill(null);
+	} else if (array.length !== length) {
+		// renew array end keep previous values
+		return new Array(length).fill(null).reduce(function (step, current, index) {
+			if (index < array.length) {
+				return [...step, array[index]];
+			}
+			return [...step, current];
+		}, []);
+	}
+	// do nothing
+	return array;
+}
+
+export default resizeArrayVariable;

package/src/use-lunatic/reducer/commons/validate-loop-condition-filter.js

@@ -0,0 +1,20 @@
+import { executeConditionFilter } from '../../commons';
+
+function validateLoopConditionFilter(state, { next, iteration }) {
+	const { pages, executeExpression } = state;
+	const { components } = pages[next];
+	const [loop] = components;
+	if (loop) {
+		const { conditionFilter } = loop;
+		if (conditionFilter) {
+			return executeConditionFilter(
+				conditionFilter,
+				executeExpression,
+				iteration
+			);
+		}
+	}
+	return true;
+}
+
+export default validateLoopConditionFilter;

package/src/use-lunatic/reducer/index.js

@@ -0,0 +1 @@
+export { default } from './reducer';

package/src/use-lunatic/reducer/reduce-go-next-page.js

@@ -0,0 +1,135 @@
+import { isOnEmptyPage, validateLoopConditionFilter } from './commons';
+import { getCompatibleVTLExpression } from '../commons';
+import { createValidateReducer } from './validate-controls';
+
+function getNextPage(state) {
+	const { pager } = state;
+	const { page, maxPage } = pager;
+	const p = Number.parseInt(page);
+	const mp = maxPage;
+	if (p < mp) {
+		return `${p + 1}`;
+	}
+	return `${maxPage}`;
+}
+
+function reduceNextSubPage(state) {
+	const { pager } = state;
+	const { subPage } = pager;
+	return {
+		...state,
+		pager: { ...pager, subPage: subPage + 1 },
+		errors: undefined,
+	};
+}
+
+function reduceNextIteration(state) {
+	const { pager } = state;
+	const { iteration } = pager;
+	return {
+		...state,
+		pager: { ...pager, subPage: 0, iteration: iteration + 1 },
+		errors: undefined,
+	};
+}
+
+function reduceNextPage(state, { next, iterations }) {
+	const { pager } = state;
+	return {
+		...state,
+		isInLoop: false,
+		pager: {
+			...pager,
+			page: next,
+			iteration: undefined,
+			nbIterations: undefined,
+			subPage: undefined,
+			nbSubPages: undefined,
+		},
+		errors: undefined,
+	};
+}
+
+function reduceStartLoop(state, { next, iterations, loopDependencies }) {
+	const { pages, pager, executeExpression } = state;
+	const { subPages } = pages[next];
+
+	if (!validateLoopConditionFilter(state, { next })) {
+		return {
+			...state,
+			pager: {
+				...pager,
+				page: next,
+				subPage: undefined,
+				nbSubPages: undefined,
+				iteration: undefined,
+				nbIterations: undefined,
+			},
+			errors: undefined,
+		};
+	}
+	/* 
+	
+	
+	
+	*/
+	const nbIterations = executeExpression(
+		getCompatibleVTLExpression(iterations),
+		{
+			bindingDependencies: loopDependencies,
+			iteration: undefined,
+		}
+	);
+
+	if (Array.isArray(subPages)) {
+		return {
+			...state,
+			isInLoop: true,
+			pager: {
+				...pager,
+				page: next,
+				subPage: 0,
+				nbSubPages: subPages.length,
+				iteration: 0,
+				nbIterations,
+			},
+			errors: undefined,
+		};
+	}
+	return state;
+}
+
+function validateChange(state) {
+	if (isOnEmptyPage(state)) {
+		return reduceGoNextPage(state);
+	}
+
+	return state;
+}
+
+function reduceGoNextPage(state) {
+	const { pages, isInLoop, pager } = state;
+	const { iteration, nbIterations, subPage, nbSubPages, page } = pager;
+
+	if (isInLoop && subPage < nbSubPages - 1) {
+		return validateChange(reduceNextSubPage(state));
+	}
+	if (isInLoop && subPage === nbSubPages - 1 && iteration < nbIterations - 1) {
+		return validateChange(reduceNextIteration(state));
+	}
+
+	const next = getNextPage(state);
+	const { isLoop, iterations, loopDependencies } = pages[next];
+	if (next === page) {
+		// TODO on devrait jamais en arriver là !
+	}
+
+	if (isLoop) {
+		return validateChange(
+			reduceStartLoop(state, { next, iterations, loopDependencies })
+		);
+	}
+	return validateChange(reduceNextPage(state, { next }));
+}
+
+export default createValidateReducer(reduceGoNextPage);

package/src/use-lunatic/reducer/reduce-go-previous-page.js

@@ -0,0 +1,133 @@
+import { isOnEmptyPage } from './commons';
+import { validateLoopConditionFilter } from './commons';
+import { getCompatibleVTLExpression } from '../commons';
+
+function getPreviousPage(pager) {
+	const { page } = pager;
+	const p = Number.parseInt(page);
+	if (p > 1) {
+		return `${page - 1}`;
+	}
+	return page;
+}
+
+function goStartLoop(state, { previous, iterations, loopDependencies }) {
+	const { pages, pager, executeExpression } = state;
+	const { subPages } = pages[previous];
+
+	//TODO: check if loop components are all filtered
+
+	// if (validateLoopConditionFilter(state, { next: previous })) {
+	// 	return {
+	// 		...state,
+	// 		pager: {
+	// 			...pager,
+	// 			page: previous,
+	// 			subPage: undefined,
+	// 			nbSubPages: undefined,
+	// 			iteration: undefined,
+	// 			nbIterations: undefined,
+	// 		},
+	// 	};
+	// }
+
+	if (Array.isArray(subPages)) {
+		const nbIterations = executeExpression(
+			getCompatibleVTLExpression(iterations),
+			{
+				bindingDependencies: loopDependencies,
+			}
+		);
+		return {
+			...state,
+			isInLoop: true,
+			pager: {
+				...pager,
+				page: previous,
+				subPage: subPages.length - 1,
+				nbSubPages: subPages.length,
+				iteration: nbIterations - 1,
+				nbIterations,
+			},
+		};
+	}
+	return state;
+}
+
+function goPreviousSubPage(state) {
+	const { pager } = state;
+	const { subPage } = pager;
+
+	return {
+		...state,
+		pager: { ...pager, subPage: subPage - 1 },
+	};
+}
+
+function goPreviousIteration(state) {
+	const { pager, pages } = state;
+	const { iteration, page } = pager;
+	const { subPages } = pages[page];
+
+	return {
+		...state,
+		pager: { ...pager, subPage: subPages.length - 1, iteration: iteration - 1 },
+	};
+}
+
+function goPreviousPage(state, { previous }) {
+	const { pager } = state;
+	const { page } = pager;
+
+	if (previous !== page) {
+		return {
+			...state,
+			isInLoop: false,
+			pager: {
+				...pager,
+				page: previous,
+				iteration: undefined,
+				nbIterations: undefined,
+				subPage: undefined,
+				nbSubPages: undefined,
+			},
+		};
+	}
+
+	return state;
+}
+
+function validateChange(state) {
+	if (isOnEmptyPage(state)) {
+		return reduceGoPreviousPage(state);
+	}
+
+	return state;
+}
+
+function reduceGoPreviousPage(state) {
+	const { pages, pager, isInLoop } = state;
+	const { iteration, subPage } = pager;
+
+	// dans une boucle et l'itération courante n'est pas finie
+	if (isInLoop && subPage > 0) {
+		return validateChange(goPreviousSubPage(state));
+	}
+	// dans une boucle, l'itération courante est finie mais il reste encore au moins une autre
+	if (isInLoop && subPage === 0 && iteration > 0) {
+		return validateChange(goPreviousIteration(state));
+	}
+
+	const previous = getPreviousPage(pager);
+	const { isLoop, iterations, loopDependencies } = pages[previous];
+	// on rentre dans une boucle
+	if (isLoop) {
+		return validateChange(
+			goStartLoop(state, { previous, loopDependencies, iterations })
+		);
+	}
+	// on change de page
+	return validateChange(goPreviousPage(state, { previous }));
+}
+
+export default reduceGoPreviousPage;

package/src/use-lunatic/reducer/reduce-handle-change/index.js

@@ -0,0 +1 @@
+export { default } from './reduce-handle-change';

package/src/use-lunatic/reducer/reduce-handle-change/reduce-cleaning.js

@@ -0,0 +1,44 @@
+import { getCompatibleVTLExpression } from '../../commons';
+
+function reduceCleaning(state, action) {
+	const { payload } = action;
+	const { response } = payload;
+	const { executeExpression, cleaning, updateBindings, variables, pager } =
+		state;
+	const { iteration } = pager;
+	if (response) {
+		const { name } = response;
+		if (name in cleaning) {
+			const expressions = cleaning[name];
+			const delta = Object.entries(expressions).reduce(function (
+				step,
+				[key, expression]
+			) {
+				const isCleaning = executeExpression(
+					getCompatibleVTLExpression(expression),
+					{ iteration }
+				);
+				if (!isCleaning && key in variables) {
+					const variableRoot = variables[key];
+					const { variable } = variableRoot;
+					const initialValue = variable?.values?.COLLECTED || null;
+					updateBindings(key, initialValue);
+					return { ...step, [key]: { ...variableRoot, value: initialValue } };
+				}
+				return step;
+			},
+			{});
+
+			return {
+				...state,
+				variables: {
+					...variables,
+					...delta,
+				},
+			};
+		}
+	}
+	return state;
+}
+
+export default reduceCleaning;

package/src/use-lunatic/reducer/reduce-handle-change/reduce-handle-change.js

@@ -0,0 +1,81 @@
+import reduceVariablesArray from './reduce-variables-array';
+import reduceVariablesSimple from './reduce-variables-simple';
+import reduceCleaning from './reduce-cleaning';
+import reduceMissing from './reduce-missing';
+import reduceResizing from './reduce-resizing';
+
+function isOnSubPage(pager) {
+	const { subPage } = pager;
+	return subPage !== undefined;
+}
+
+function updateVariables(state, action) {
+	const { payload } = action;
+	const { response, value, args = {} } = payload;
+	const { name } = response;
+	const { loop, index, length } = args;
+
+	const { pager, variables } = state;
+	const { nbIterations, iteration } = pager;
+
+	if (loop) {
+		const variablesNext = reduceVariablesArray(variables, {
+			name,
+			value,
+			index,
+			length,
+		});
+		return { ...state, variables: variablesNext };
+	} else if (isOnSubPage(pager)) {
+		const variablesNext = reduceVariablesArray(variables, {
+			name,
+			value,
+			index: iteration,
+			length: nbIterations,
+		});
+
+		return { ...state, variables: variablesNext };
+	} else {
+		const variablesNext = reduceVariablesSimple(variables, { name, value });
+		return { ...state, variables: variablesNext };
+	}
+}
+
+/**
+ * met à jour bindings pour l'exe du VTL (en appelant la fonction fournit par createExecuteExpression)
+ * @param {*} state
+ * @param {*} action
+ * @returns
+ */
+function updateBindings(state, action) {
+	const { payload } = action;
+	const { response } = payload;
+	const { name } = response;
+	const { updateBindings, variables } = state;
+	const { value } = variables[name];
+
+	updateBindings(name, value);
+
+	return state;
+}
+
+/**
+ *
+ * @param {*} state
+ * @param {*} action
+ * @returns
+ */
+function reduceHandleChange(state, action) {
+	return reduceResizing(
+		reduceMissing(
+			reduceCleaning(
+				updateBindings(updateVariables(state, action), action),
+				action
+			),
+			action
+		),
+		action
+	);
+}
+
+export default reduceHandleChange;

package/src/use-lunatic/reducer/reduce-handle-change/reduce-missing.js

@@ -0,0 +1,34 @@
+function buildMissingValue(state, oldValue) {
+	const {
+		pager: { iteration },
+	} = state;
+	// Root question
+	if (iteration === undefined) return null;
+	// Loop question
+	const newValue = [...oldValue];
+	newValue[iteration] = null;
+	return newValue;
+}
+
+function reduceMissing(state, action) {
+	const {
+		payload: {
+			response: { name },
+		},
+	} = action;
+	const { missingBlock } = state;
+	if (name in missingBlock) {
+		const { variables, updateBindings } = state;
+		const toClean = missingBlock[name];
+		const delta = toClean.reduce((acc, variableName) => {
+			const { value, ...rest } = variables[variableName];
+			updateBindings(variableName, null);
+			const newValue = buildMissingValue(state, value);
+			return { ...acc, [variableName]: { ...rest, value: newValue } };
+		}, {});
+		return { ...state, variables: { ...variables, ...delta } };
+	}
+	return state;
+}
+
+export default reduceMissing;

package/src/use-lunatic/reducer/reduce-handle-change/reduce-resizing.js

@@ -0,0 +1,29 @@
+import { getCompatibleVTLExpression } from '../../commons';
+import { resizeArrayVariable } from '../commons';
+
+function reduceResizing(state, action) {
+	const {
+		payload: {
+			response: { name },
+		},
+	} = action;
+	const { resizing, variables, updateBindings } = state;
+	if (name in resizing) {
+		const { size, variables: variableArray } = resizing[name];
+		const { executeExpression } = state;
+		const sizeValue = executeExpression(getCompatibleVTLExpression(size));
+		const newArray = variableArray.reduce((acc, v) => {
+			const { value } = variables[v];
+			const newValue = resizeArrayVariable(value, sizeValue);
+			updateBindings(v, newValue);
+			return {
+				...acc,
+				[v]: { ...variables[v], value: newValue },
+			};
+		}, {});
+		return { ...state, variables: { ...variables, ...newArray } };
+	}
+	return state;
+}
+
+export default reduceResizing;

package/src/use-lunatic/reducer/reduce-handle-change/reduce-variables-array.js

@@ -0,0 +1,22 @@
+import { resizeArrayVariable } from '../commons';
+
+function reduceVariablesArray(variables, { name, value, index, length }) {
+	if (name in variables) {
+		const variable = variables[name];
+		const { value: previousValue } = variable;
+
+		// validation de la valeur courante : si pas un tableau ou si la taille du tableau a changé
+		let valueNext = resizeArrayVariable([...previousValue], length);
+
+		// value affectation
+		valueNext[index] = value;
+		return {
+			...variables,
+			[name]: { ...variable, value: valueNext },
+		};
+	}
+
+	return variables;
+}
+
+export default reduceVariablesArray;

package/src/use-lunatic/reducer/reduce-handle-change/reduce-variables-simple.js

@@ -0,0 +1,13 @@
+function reduceVariablesSimple(variables, { name, value }) {
+	if (name in variables) {
+		const variable = variables[name];
+		return {
+			...variables,
+			[name]: { ...variable, value },
+		};
+	}
+
+	return variables;
+}
+
+export default reduceVariablesSimple;