From 29e1c40ea06dff6788e20f14d925c71102801336 Mon Sep 17 00:00:00 2001
From: Mael Thomas <mael.thomas@data.gouv.fr>
Date: Tue, 7 Feb 2017 20:10:04 +0100
Subject: [PATCH] =?UTF-8?q?[CDD][moteur]=20ajout=20de=20la=20maj=20chomage?=
 =?UTF-8?q?=20->=20nouveau=20m=C3=A9canisme?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 règles/entités/salariat/Salariat.CDD.yaml     | 12 +--
 .../cdd/indemnité_fin_contrat.yaml            |  2 +-
 .../cdd/majoration-chomage.yaml               | 18 +++--
 source/components/CDD.css                     |  1 -
 source/components/CDD.js                      |  2 +
 source/components/Results.js                  |  9 ++-
 source/engine/expressions.js                  | 17 ++--
 source/engine/rules.js                        |  2 +-
 source/engine/traverse.js                     | 78 ++++++++++++-------
 source/reducers.js                            |  8 +-
 10 files changed, 91 insertions(+), 58 deletions(-)

diff --git a/règles/entités/salariat/Salariat.CDD.yaml b/règles/entités/salariat/Salariat.CDD.yaml
index e8c7ee8f0..2f7582c5e 100644
--- a/règles/entités/salariat/Salariat.CDD.yaml
+++ b/règles/entités/salariat/Salariat.CDD.yaml
@@ -8,20 +8,20 @@
 
 - Variable: durée
   attache: Salariat . CDD
-  type: période
+  contrainte: période
   description: Durée du contrat de travail
 
 - Variable: motif de recours
   alias: motif # alias utilisé dans l'article L. 1242-1
   attache: Salariat . CDD
   description: |
-    Le CDD est un contrat d'exception: son recours doit être autorisé par l'une des motifs suivants
+    Le CDD est un contrat d'exception: son recours doit être autorisé par l'un des motifs suivants
   choix exclusifs:
     - saisonnier
     - jeune vacances
     - sénior
     - usage
-    - accroissement temporaire d'activité
+    - accroissement temporaire activité
     # remplacement salarié ?
     # mission ?
     # ambiguité : l'alternance / l'apprentissage / la fpro sont-ils des justification de CDD ?
@@ -49,7 +49,7 @@
   attache: Salariat . CDD . motif
   titre: Contrat saisonnier
 
-- Variable: accroissement temporaire d'activité
+- Variable: accroissement temporaire activité
   attache: Salariat . CDD . motif
   titre: Accroissement temporaire d'activité
 
@@ -66,7 +66,9 @@
 - Variable: usage # Similaire pour intérim, mais domaines différents
   attache: Salariat . CDD . motif
   titre: Contrat d'usage
-  référence: https://www.service-public.fr/particuliers/vosdroits/F32476
+  # alias: extra
+  références:
+    service-public.fr: https://www.service-public.fr/professionnels-entreprises/vosdroits/F33693
   # concerne: emploi temporaire par nature
   formule:
     choix exclusifs:
diff --git a/règles/rémunération-travail/cdd/indemnité_fin_contrat.yaml b/règles/rémunération-travail/cdd/indemnité_fin_contrat.yaml
index 15fb4dd7f..7a326b659 100644
--- a/règles/rémunération-travail/cdd/indemnité_fin_contrat.yaml
+++ b/règles/rémunération-travail/cdd/indemnité_fin_contrat.yaml
@@ -1,4 +1,4 @@
-- Indemnité: Fin de contrat
+- Indemnité: fin de contrat
   attache: CDD
   attributs:
     type: indemnité
diff --git a/règles/rémunération-travail/cdd/majoration-chomage.yaml b/règles/rémunération-travail/cdd/majoration-chomage.yaml
index b96cb2d61..734de3ec5 100644
--- a/règles/rémunération-travail/cdd/majoration-chomage.yaml
+++ b/règles/rémunération-travail/cdd/majoration-chomage.yaml
@@ -5,18 +5,20 @@
     type: majoration
 
   description: Majoration des contributions patronales d’assurance chômage pour les contrats à durée déterminée courts (CDD)
-  concerne: Salariat . CDD . durée <= 3
+  non applicable si:
+    l'une de ces conditions:
+      - Salariat . CDD . durée > 3
+      - Salariat . CDD . événements . CDD poursuivi en CDI
   formule:
     linéaire:
-      assiette: assiette cotisations sociales
+      assiette: Salariat . salaire de base
       taux:
         logique numérique:
-          - Salariat . CDD . événements . CDD poursuivi en CDI: 0%
-          - Salariat . CDD . motif . accroissement temporaire d'activité:
-            - Salariat . CDD . durée ≤ 1: 3% # TODO 1 mois, pas 1 rien, évidemment
-            - Salariat . CDD . durée ≤ 3: 1.5%
-          - Salariat . CDD . motif . usage:
-            - Salariat . CDD . durée ≤ 3: 0.5%
+          Salariat . CDD . motif . accroissement temporaire activité:
+            Salariat . CDD . durée <= 1: 3% # TODO 1 mois, pas 1 rien, évidemment
+            Salariat . CDD . durée <= 3: 1.5%
+          Salariat . CDD . motif . usage:
+            Salariat . CDD . durée <= 3: 0.5%
 
 
 
diff --git a/source/components/CDD.css b/source/components/CDD.css
index f22f16a80..d59a74836 100644
--- a/source/components/CDD.css
+++ b/source/components/CDD.css
@@ -32,7 +32,6 @@
 }
 
 #sim #help {
-	visibility: hidden;
 	border: 1px solid #ccc;
 	border-radius: 2px;
 	font-style: italic;
diff --git a/source/components/CDD.js b/source/components/CDD.js
index 839309c3a..308af86ba 100644
--- a/source/components/CDD.js
+++ b/source/components/CDD.js
@@ -14,6 +14,7 @@ class Aide extends Component {
 		if (!steps.length) return null
 		let [{dependencyOfVariables, helpText}] = steps
 		return <section id="help">
+			{/*
 			{helpText}
 			<div className="dependency-of">
 				Cette question est nécessaire pour calculer :
@@ -23,6 +24,7 @@ class Aide extends Component {
 					)}
 				</ul>
 			</div>
+			*/}
 		</section>
 	}
 }
diff --git a/source/components/Results.js b/source/components/Results.js
index 6f410f989..04824b364 100644
--- a/source/components/Results.js
+++ b/source/components/Results.js
@@ -3,18 +3,19 @@ import React, { Component } from 'react'
 export default class Results extends Component {
 	render() {
 		let {analysedSituation} = this.props
+		console.log('analysedSituation', analysedSituation)
 		return (
 			<section id="results">
 				<h2>Vos obligations</h2>
 				<ul>
-					{analysedSituation.map(({name, type, derived: [dependencies, value]}) =>
+					{analysedSituation.map(({name, type, derived: {missingVariables, computedValue}}) =>
 						<li key={name}>
 							<h3>{type} {name}</h3>
 							<p className="value">
-							{dependencies && dependencies.length ?
+							{missingVariables && missingVariables.length ?
 								'Répondez aux questions !'
-								: value != null ?
-									value + '€'
+								: computedValue != null ?
+									computedValue + '€'
 									: 'Non applicable'
 							}
 							</p>
diff --git a/source/engine/expressions.js b/source/engine/expressions.js
index 5cb9366ed..9a0a2e249 100644
--- a/source/engine/expressions.js
+++ b/source/engine/expressions.js
@@ -6,15 +6,17 @@ import {parentName, nameLeaf} from './rules'
 
 // composants des regexps
 let
-	vn = '[A-Za-z\\u00C0-\\u017F\\s]+', //variableName
-	sep = '\\s\\.\\s'
+	vp = '[A-Za-z\\u00C0-\\u017F\\s]+', // variable part
+	sep = '\\s\\.\\s',
+	vn = `(${vp}(?:${sep}${vp})*)`
 
 let expressionTests = {
 	// 'negatedVariable': v => /!((?:[a-z0-9]|\s|_)+)/g.exec(v),
 	// 'variableIsIncludedIn': v => /((?:[a-z0-9]|\s|_)+)⊂*/g.exec(v),
-	'variableComparedToNumber': v => /([\w\s]+(?:\s\.\s[\w\s]+)*)\s([<>]=?)\s([0-9]+)/g.exec(v),
+	// 'variableComparedToNumber': v => /([\w\s]+(?:\s\.\s[\w\s]+)*)\s([<>]=?)\s([0-9]+)/g.exec(v),
+	'variableComparedToNumber': v => new RegExp(`^${vn}\\s([<>]=?)\\s([0-9]+)$`, 'g').exec(v),
 	'variableEqualsString': v => /([\w\s]+(?:\s\.\s[\w\s]+)*)\s=\s([\w\s]+)/g.exec(v),
-	'variable': v => new RegExp(`^(${vn}(?:${sep}${vn})*)$`, 'g').exec(v)
+	'variable': v => new RegExp(`^${vn}$`, 'g').exec(v)
 }
 
 export let recognizeExpression = value => {
@@ -29,6 +31,7 @@ export let recognizeExpression = value => {
 
 	match = expressionTests['variableComparedToNumber'](value)
 	if (match) {
+
 		let [, variableName, symbol, number] = match
 		return [variableName, situation => eval(`situation("${variableName}") ${symbol} ${number}`)] // eslint-disable-line no-unused-vars
 	}
@@ -48,9 +51,9 @@ export let recognizeExpression = value => {
 				// let yo = parentName(variableName),
 				// ya = nameLeaf(variableName),
 				// yi = situation(parentName(variableName))
-				// debugger;
-				return removeDiacritics(situation(variableName)) == 'oui' ||
-				removeDiacritics(situation(parentName(variableName))) == nameLeaf(variableName)
+				// debugger
+				return situation(variableName) == 'oui' ||
+				situation(parentName(variableName)) == nameLeaf(variableName)
 			}]
 	}
 }
diff --git a/source/engine/rules.js b/source/engine/rules.js
index 090cfd21f..bea46d987 100644
--- a/source/engine/rules.js
+++ b/source/engine/rules.js
@@ -60,7 +60,7 @@ export let searchRules = searchInput =>
 
 export let findRuleByDottedName = dottedName => do {
 	let found = entityRules.find(rule => rule.dottedName == dottedName)
-	found || console.log('dottedName = ', dottedName, ' a déserté')
+	found
 }
 
 export let findGroup = R.pipe(
diff --git a/source/engine/traverse.js b/source/engine/traverse.js
index 42d3576d1..e015d4eb8 100644
--- a/source/engine/traverse.js
+++ b/source/engine/traverse.js
@@ -8,8 +8,10 @@ import {recognizeExpression} from './expressions'
 let selectedRules = rules.filter(rule =>
 			R.contains(
 				enrichRule(rule).name,
-				['CIF CDD', 'Fin de contrat']
-				// ['CIF CDD']
+				[
+					'CIF CDD', 'fin de contrat',
+					'majoration chômage CDD'
+				]
 			)
 		)
 
@@ -18,11 +20,15 @@ let knownVariable = (situation, variableName) => typeof R.or(
 	situation(parentName(variableName))
 ) !== 'undefined'
 
+let transformPercentage = s =>
+	s.indexOf('%') > -1 ?
+		+s.replace('%', '') / 100 :
+		+s
 
 let deriveRule = situationGate => R.pipe(
 	R.toPairs,
 	// Reduce to [variables needed to compute that variable, computed variable value]
-	R.reduce(([variableNames, result], [key, value]) => {
+	R.reduce(({missingVariables, computedValue}, [key, value]) => {
 		if (key === 'concerne') {
 			let [variableName, evaluation] = recognizeExpression(value)
 			// Si cette variable a été renseignée
@@ -30,21 +36,19 @@ let deriveRule = situationGate => R.pipe(
 				// Si l'expression n'est pas vraie...
 				if (!evaluation(situationGate)) {
 					// On court-circuite toute la variable, et on n'a besoin d'aucune information !
-					return R.reduced([[]])
+					return R.reduced({missingVariables: []})
 				} else {
 					// Sinon, on continue
-					return [variableNames]
+					return {missingVariables}
 				}
 			// sinon on demande la valeur de cette variable
-			} else return [[...variableNames, variableName]]
+			} else return { missingVariables: [...missingVariables, variableName] }
 		}
 
 		if (key === 'non applicable si') {
 			let conditions = value['l\'une de ces conditions']
 			let [subVariableNames, reduced] = R.reduce(([variableNames], expression) => {
-
 				let [variableName, evaluation] = recognizeExpression(expression)
-
 				if (knownVariable(situationGate, variableName)) {
 					if (evaluation(situationGate)) {
 						return R.reduced([[], true])
@@ -54,8 +58,9 @@ let deriveRule = situationGate => R.pipe(
 				}
 				return [[...variableNames, variableName]]
 			}, [[], null])(conditions)
-			if (reduced) return R.reduced([[]])
-			else return [variableNames.concat(subVariableNames)]
+
+			if (reduced) return R.reduced({missingVariables: []})
+			else return {missingVariables: [...missingVariables, ...subVariableNames]}
 		}
 
 		if (key === 'formule') {
@@ -67,30 +72,49 @@ let deriveRule = situationGate => R.pipe(
 					assietteValue = situationGate(assietteVariableName),
 					unknownAssiette = assietteValue == undefined
 
-				if (unknownAssiette) {
-					return [[...variableNames, assietteVariableName]]
-				} else {
-					if (variableNames.length > 0) {
-						return [variableNames]
-					}
-				}
-
 				// Arrivés là, cette formule devrait être calculable !
+				let {missingVariables: tauxMissingVariables = [], computedValue} = typeof taux !== 'string' ?
+					do {
+						let numericalLogic = taux['logique numérique']
+						if (!numericalLogic) throw 'On ne sait pas pour l\'instant traiter ce mécanisme de taux'
 
-				// A propos du taux
-				if (typeof taux !== 'string' && typeof taux !== 'number') {
-					throw 'Oups, pas de taux compliqués s\'il-vous-plaît'
+						let treatNumericalLogic = numericalLogic => {
+							if (typeof numericalLogic == 'string') {
+								return new Object({computedValue: assietteValue * transformPercentage(numericalLogic)})
+							} else {
+								return R.pipe(
+									R.toPairs(),
+									R.reduce(({missingVariables}, [expression, subLogic]) => {
+										let [variableName, evaluation] = recognizeExpression(expression)
+										if (knownVariable(situationGate, variableName)) {
+											if (evaluation(situationGate)) {
+												return R.reduced(treatNumericalLogic(subLogic))
+											} else {
+												return {missingVariables}
+											}
+										} else return {missingVariables: [...missingVariables, variableName]}
+									}, {missingVariables: []})
+							)(numericalLogic)
+							}}
+						treatNumericalLogic(numericalLogic)
+					} : ({computedValue: assietteValue * transformPercentage(taux)})
+
+				let formulaResult = {
+					missingVariables: [
+						...missingVariables,
+						...(unknownAssiette ? [assietteVariableName] : []),
+						...tauxMissingVariables
+					],
+					computedValue
 				}
-				let tauxValue = taux.indexOf('%') > -1 ?
-					+taux.replace('%', '') / 100 :
-					+taux
 
-				return R.reduced([null, assietteValue * tauxValue])
+				return computedValue != null ? R.reduced(formulaResult) : formulaResult
+
 			}
 		}
 
-		return [variableNames]
-	}, [[], null])
+		return {missingVariables}
+	}, {missingVariables: []})
 	)
 
 let analyseRule = situationGate =>
diff --git a/source/reducers.js b/source/reducers.js
index 47dafe8f1..a9e64ffaf 100644
--- a/source/reducers.js
+++ b/source/reducers.js
@@ -52,7 +52,6 @@ export default reduceReducers(
 	(state, action) => {
 		if (action.type == STEP_ACTION || action.type == START_CONVERSATION) {
 			let {newState, name} = action
-			console.log('action', action)
 			// une étape vient d'être validée : on va changer son état
 			let newSteps = R.pipe(
 				R.map(step => step.name == name ? {...step, state: newState} : step),
@@ -68,7 +67,7 @@ export default reduceReducers(
 				),
 
 				missingVariables = R.pipe(
-					R.map( ({name, derived: [missingVariables]}) =>
+					R.map( ({name, derived: {missingVariables}}) =>
 						(missingVariables || []).map(mv => [mv, name])
 					),
 					R.unnest,
@@ -91,10 +90,11 @@ export default reduceReducers(
 								[R.isNil, () => variables.map(dottedName => {
 									let rule = findRuleByDottedName(dottedName)
 									return Object.assign(constructStepMeta(rule),
-										rule.contrainte == 'nombre positif' ?
+										rule.contrainte == 'nombre positif' ||
+										rule.contrainte == 'période' ?
 										{
 											component: Input,
-											defaultValue: 0,
+											defaultValue: 1,
 											valueType: euro,
 											attributes: {
 												inputMode: 'numeric',