@cnamts/synapse 1.0.23 → 1.0.24

package/src/components/NirField/useNirValidation.ts

@@ -0,0 +1,271 @@
+import { type ValidationRule as SyValidationRule } from '@/composables/validation/useValidation'
+import { computed, nextTick, onBeforeUnmount, onMounted, ref, type Ref } from 'vue'
+import { checkNIR, isNIRKeyValid } from './nirValidation'
+import type { locales } from './locales'
+import { useValidation } from '@/composables/unifyValidation/useValidation'
+import type { SyTextField } from '@/main'
+import type { ValidationRule as VuetifyValidationRule } from 'vuetify'
+
+export type NirValidationProps = {
+	customKeyRules?: SyValidationRule[]
+	customKeyWarningRules?: SyValidationRule[]
+	customNumberRules?: SyValidationRule[]
+	customNumberWarningRules?: SyValidationRule[]
+	customRulesPrecedence?: boolean
+	disabled?: boolean
+	isValidateOnBlur?: boolean
+	keyLabel?: string
+	keyRules?: VuetifyValidationRule[]
+	nirType?: 'simple' | 'complexe'
+	numberLabel?: string
+	numberRules?: VuetifyValidationRule[]
+	readonly?: boolean
+	required?: boolean
+	showSuccessMessages?: boolean
+	useVuetifyValidation?: boolean
+}
+
+/**
+ * Handle validation for NIR fields, including both the number and the key
+ */
+export function useNirValidation(
+	numberValue: Ref<string>,
+	keyValue: Ref<string>,
+	unmaskedNumberValue: Ref<string>,
+	unmaskedKeyValue: Ref<string>,
+	readonly: Ref<boolean>,
+	disabled: Ref<boolean>,
+	required: Ref<boolean>,
+	numberField: Ref<InstanceType<typeof SyTextField> | null>,
+	keyField: Ref<InstanceType<typeof SyTextField> | null>,
+	customLocale: Ref<typeof locales>,
+	numberLabel: Ref<string>,
+	keyLabel: Ref<string>,
+	customNumberRules: Ref<SyValidationRule[]>,
+	customKeyRules: Ref<SyValidationRule[]>,
+	customNumberWarningRules: Ref<SyValidationRule[]>,
+	customKeyWarningRules: Ref<SyValidationRule[]>,
+	displayKey: Ref<boolean>,
+	customRulesPrecedence: Ref<boolean>,
+	nirType: Ref<'simple' | 'complexe'>,
+	label: Ref<string>,
+	showSuccessMessages: Ref<boolean>,
+	disableErrorHandling: Ref<boolean>,
+	isValidateOnBlur: Ref<boolean>,
+	useVuetifyValidation: Ref<boolean>,
+	vuetifyNumberRules: Ref<VuetifyValidationRule[]>,
+	vuetifyKeyRules: Ref<VuetifyValidationRule[]>,
+) {
+	// Règles de validation
+	const numberRules = computed(() => {
+		if (useVuetifyValidation.value) {
+			return []
+		}
+		const rules: SyValidationRule[] = []
+		if (required.value) {
+			rules.push({
+				type: 'required',
+				options: {
+					message: customLocale.value.errorRequiredNumber,
+					fieldIdentifier: numberLabel.value,
+				},
+			})
+		}
+
+		// Ajout des règles personnalisées avec prévalence si demandé
+		if (customRulesPrecedence.value && customNumberRules.value && customNumberRules.value.length > 0) {
+			rules.push(...customNumberRules.value.map(rule => ({
+				...rule,
+				options: rule.options || {},
+			})))
+		}
+
+		// Règle de validation standard du NIR
+		rules.push({
+			type: 'custom',
+			options: {
+				validate: (value: string) => {
+					if (!value) return true
+					// Ne valider que si tous les caractères sont saisis
+					if (value.length < 13) {
+						return customLocale.value.errorInvalidNumber || customLocale.value.errorInvalidNumber
+					}
+					const result = checkNIR(value, nirType.value)
+					return result ? true : customLocale.value.errorInvalidNumber || customLocale.value.errorInvalidNumber
+				},
+				message: customLocale.value.errorInvalidNumber,
+				successMessage: customLocale.value.successNumberValid,
+				fieldIdentifier: numberLabel.value,
+			},
+		})
+
+		// Ajout des règles personnalisées sans prévalence (comportement par défaut)
+		if (!customRulesPrecedence.value && customNumberRules.value && customNumberRules.value.length > 0) {
+			rules.push(...customNumberRules.value.map(rule => ({
+				...rule,
+				options: rule.options || {},
+			})))
+		}
+
+		return rules
+	})
+
+	const keyRules = computed(() => {
+		if (useVuetifyValidation.value) {
+			return []
+		}
+		const rules: SyValidationRule[] = []
+		if (required.value) {
+			rules.push({
+				type: 'required',
+				options: {
+					message: customLocale.value.errorRequiredKey,
+					fieldIdentifier: keyLabel.value,
+				},
+			})
+		}
+
+		const validateKey = (value: string) => {
+			if (!value) return true
+			if (!unmaskedNumberValue.value) return true
+			const fullNir = unmaskedNumberValue.value + value
+			return isNIRKeyValid(fullNir)
+		}
+
+		// Ajout des règles personnalisées
+		if (customKeyRules.value) {
+			rules.push(...customKeyRules.value)
+		}
+
+		// Ajout de la règle de validation par défaut si pas de règle personnalisée avec validation de clé
+		if (!customKeyRules.value?.some(rule => rule.options.validate)) {
+			rules.push({
+				type: 'custom',
+				options: {
+					validate: validateKey,
+					message: customLocale.value.errorInvalidKey,
+					successMessage: customLocale.value.successKeyValid,
+					fieldIdentifier: keyLabel.value,
+				},
+			})
+		}
+
+		return rules
+	})
+
+	// État pour suivre si une validation est en cours
+	const isValidating = ref(false)
+	const shouldValidateOnBlur = ref(false)
+	const numberFieldFocused = ref(false)
+	const keyFieldFocused = ref(false)
+
+	// update focus state on blur and focus
+	const onNumberFocus = () => {
+		numberFieldFocused.value = true
+	}
+	const onNumberBlur = () => {
+		numberFieldFocused.value = false
+	}
+	const onKeyFocus = () => {
+		keyFieldFocused.value = true
+	}
+	const onKeyBlur = () => {
+		keyFieldFocused.value = false
+	}
+
+	let numberInput: HTMLInputElement | null = null
+	let keyInput: HTMLInputElement | null = null
+
+	onMounted(() => {
+		numberInput = numberField.value?.$el?.querySelector('input') ?? null
+		if (numberInput) {
+			numberInput.addEventListener('focus', onNumberFocus)
+			numberInput.addEventListener('blur', onNumberBlur)
+		}
+
+		keyInput = keyField.value?.$el?.querySelector('input') ?? null
+		if (keyInput) {
+			keyInput.addEventListener('focus', onKeyFocus)
+			keyInput.addEventListener('blur', onKeyBlur)
+		}
+	})
+
+	onBeforeUnmount(() => {
+		numberInput?.removeEventListener('focus', onNumberFocus)
+		numberInput?.removeEventListener('blur', onNumberBlur)
+		keyInput?.removeEventListener('focus', onKeyFocus)
+		keyInput?.removeEventListener('blur', onKeyBlur)
+	})
+
+	const numberValidation = useValidation({
+		modelValue: numberValue,
+		readonly,
+		disabled,
+		required,
+		isValidateOnBlur,
+		showSuccessMessages,
+		disableErrorHandling,
+		useVuetifyValidation,
+		label,
+		customRules: numberRules,
+		customWarningRules: computed(() => unmaskedNumberValue.value.length === 13 ? customNumberWarningRules.value : []),
+		rules: vuetifyNumberRules,
+		focused: numberFieldFocused,
+	})
+
+	const keyValidation = useValidation({
+		modelValue: keyValue,
+		readonly,
+		disabled,
+		required,
+		isValidateOnBlur,
+		showSuccessMessages,
+		disableErrorHandling,
+		useVuetifyValidation,
+		label,
+		customRules: keyRules,
+		customWarningRules: computed(() => (displayKey.value && unmaskedKeyValue.value.length === 2) ? customKeyWarningRules.value : []),
+		rules: vuetifyKeyRules,
+		focused: keyFieldFocused,
+	})
+
+	// Validation des champs
+	const validateFields = async (onBlur = false) => {
+		// Éviter les validations redondantes
+		if (isValidating.value) {
+			shouldValidateOnBlur.value = shouldValidateOnBlur.value || onBlur
+			return true
+		}
+
+		isValidating.value = true
+
+		await numberValidation.validate()
+
+		if (displayKey.value) {
+			await keyValidation.validate()
+		}
+
+		if (onBlur || shouldValidateOnBlur.value) {
+			await nextTick()
+			if (numberValidation.hasError.value) {
+				numberField.value?.$el?.querySelector?.('input')?.focus()
+			}
+			else if (keyValidation.hasError.value) {
+				keyField.value?.$el?.querySelector?.('input')?.focus()
+			}
+			shouldValidateOnBlur.value = false
+		}
+
+		isValidating.value = false
+		return !numberValidation.hasError.value && !keyValidation.hasError.value
+	}
+
+	const hasFieldErrors = computed(() => numberValidation.hasError.value || keyValidation.hasError.value)
+
+	return {
+		numberValidation,
+		keyValidation,
+		validateFields,
+		hasFieldErrors,
+	}
+}

package/src/components/PasswordField/PasswordField.stories.ts

@@ -962,9 +962,9 @@ export const WithFormValidation: Story = {
 					]
 					
 					// Fonction de soumission du formulaire
-					const handleSubmit = () => {
+					const handleSubmit = async (): Promise<void> => {
 						if (passwordFieldRef.value) {
-							const isValid = passwordFieldRef.value.validateOnSubmit()
+							const isValid = await passwordFieldRef.value.validateOnSubmit()
 							if (isValid) {
 								formStatus.value = 'Formulaire soumis avec succès !'
 							} else {
@@ -1013,9 +1013,9 @@ export const WithFormValidation: Story = {
 			]
 
 			// Fonction de soumission du formulaire
-			const handleSubmit = () => {
+			const handleSubmit = async () => {
 				if (passwordFieldRef.value) {
-					const isValid = passwordFieldRef.value.validateOnSubmit()
+					const isValid = await passwordFieldRef.value.validateOnSubmit()
 					if (isValid) {
 						formStatus.value = 'Formulaire soumis avec succès !'
 					}

package/src/components/PasswordField/PasswordField.vue

@@ -20,7 +20,7 @@
 		modelValue?: string | null
 		variantStyle?: 'outlined' | 'underlined'
 		color?: ColorType
-		label?: string
+		label: string
 		required?: boolean
 		errorMessages?: string[] | null
 		warningMessages?: string[] | null
@@ -41,7 +41,6 @@
 		modelValue: null,
 		variantStyle: 'outlined',
 		color: 'primary',
-		label: undefined,
 		required: false,
 		errorMessages: null,
 		warningMessages: null,
@@ -96,25 +95,12 @@
 			})
 		}
 
-		// Règle pour le message de succès
-		// rules.push({
-		// 	type: 'custom',
-		// 	options: {
-		// 		validate: (value: string) => value ? true : 'Ce champ est requis',
-		// 		successMessage: 'Mot de passe fort',
-		// 		fieldIdentifier: props.label || 'password',
-		// 	},
-		// })
-
 		return rules
 	})
 
 	// Initialisation du composable de validation
 	const { errors, warnings, successes, validateField } = !props.readonly
 		? useValidation({
-			customRules: defaultRules.value,
-			warningRules: props.customWarningRules || [],
-			successRules: props.customSuccessRules || [],
 			showSuccessMessages: props.showSuccessMessages,
 			fieldIdentifier: props.label || 'password',
 			disableErrorHandling: props.disableErrorHandling,
@@ -123,7 +109,7 @@
 			errors: ref<string[]>([]),
 			warnings: ref<string[]>([]),
 			successes: ref<string[]>([]),
-			validateField: () => {},
+			validateField: () => ({ hasError: false, hasWarning: false, hasSuccess: false, state: { errors: [], warnings: [], successes: [] } }),
 		}
 
 	const hasError = computed(() => errors.value.length > 0)
@@ -199,15 +185,15 @@
 		})
 	}
 
-	function handleKeydown(event: KeyboardEvent): void {
+	async function handleKeydown(event: KeyboardEvent): Promise<void> {
 		if (event.key === 'Enter') {
-			validateOnSubmit()
+			await validateOnSubmit()
 		}
 	}
 
-	const validateOnSubmit = (): boolean => {
+	const validateOnSubmit = async (): Promise<boolean> => {
 		if (props.readonly) return true // Retourner true au lieu de undefined
-		validateField(password.value, [...defaultRules.value, ...(props.customRules || [])], props.customWarningRules || [], props.customSuccessRules || [])
+		await validateField(password.value, [...defaultRules.value, ...(props.customRules || [])], props.customWarningRules || [], props.customSuccessRules || [])
 		const isValid = errors.value.length === 0
 		if (isValid) {
 			emit('submit')
@@ -280,7 +266,16 @@
 		:autocomplete="props.autocompleteType"
 		class="vd-password"
 		:validate-on="props.isValidateOnBlur ? 'blur lazy' : 'lazy'"
-		@blur="props.isValidateOnBlur && !props.readonly ? validateField(password, [...defaultRules, ...(props.customRules || [])], props.customWarningRules || [], props.customSuccessRules || []) : () => {}"
+		@blur="async () => {
+			if (props.isValidateOnBlur && !props.readonly) {
+				await validateField(
+					password,
+					[...defaultRules, ...(props.customRules || [])],
+					props.customWarningRules || [],
+					props.customSuccessRules || []
+				)
+			}
+		}"
 		@keydown="handleKeydown"
 	>
 		<template #append-inner>
@@ -293,8 +288,7 @@
 					decorative
 					class="mr-2"
 				/>
-				<!-- Utiliser un vrai élément button plutôt qu'une icône avec role="button" -->
-				<v-button
+				<VBtn
 					type="button"
 					class="password-toggle-button"
 					:aria-label="btnLabel"
@@ -311,7 +305,7 @@
 						:aria-hidden="true"
 						decorative
 					/>
-				</v-button>
+				</VBtn>
 			</div>
 			<div
 				:id="`${passwordFieldId}-status`"

package/src/components/PasswordField/tests/PasswordField.spec.ts

@@ -6,7 +6,7 @@ import { describe, it, expect } from 'vitest'
 interface PasswordFieldVM {
 	showEyeIcon: boolean
 	errors: string[]
-	validateOnSubmit: () => boolean
+	validateOnSubmit: () => Promise<boolean>
 	hasError: boolean
 	hasWarning: boolean
 	hasSuccess: boolean
@@ -65,12 +65,12 @@ describe('PasswordField.vue', () => {
 		})
 		const vm = wrapper.vm as unknown as PasswordFieldVM
 
-		const result = vm.validateOnSubmit()
+		const result = await vm.validateOnSubmit()
 		expect(result).toBe(false)
 		expect(vm.errors).toContain('Le mot de passe est requis')
 
 		await wrapper.setProps({ modelValue: 'valid-password' })
-		const validResult = vm.validateOnSubmit()
+		const validResult = await vm.validateOnSubmit()
 		expect(validResult).toBe(true)
 		expect(wrapper.emitted().submit).toBeTruthy()
 	})
@@ -78,6 +78,7 @@ describe('PasswordField.vue', () => {
 	it('displays warning and success messages', async () => {
 		const wrapper = mount(PasswordField, {
 			props: {
+				label: 'Password',
 				modelValue: 'test',
 				warningMessages: ['Attention: mot de passe court'],
 				successMessages: ['Mot de passe valide'],
@@ -97,6 +98,7 @@ describe('PasswordField.vue', () => {
 	it('handles custom validation rules', async () => {
 		const wrapper = mount(PasswordField, {
 			props: {
+				label: 'Password',
 				modelValue: 'test',
 				customRules: [{
 					type: 'custom',
@@ -141,6 +143,7 @@ describe('PasswordField.vue', () => {
 	it('displays validation states based on validation rules', async () => {
 		const wrapper = mount(PasswordField, {
 			props: {
+				label: 'Password',
 				modelValue: 'test',
 				customRules: [{
 					type: 'custom',

package/src/components/PeriodField/PeriodField.stories.ts

@@ -995,9 +995,9 @@ export const FormValidation: Story = {
 				]
 				
 				// Soumission du formulaire
-				const submitForm = () => {
+				const submitForm = async (): Promise<void> => {
 				if (periodFieldRef.value) {
-					const isValid = periodFieldRef.value.validateOnSubmit()
+					const isValid = await periodFieldRef.value.validateOnSubmit()
 					if (isValid) {
 						formStatus.value = 'Formulaire soumis avec succès !'
 						isFormSubmitted.value = true
@@ -1035,9 +1035,9 @@ export const FormValidation: Story = {
 			]
 
 			// Soumission du formulaire
-			const submitForm = () => {
+			const submitForm = async (): Promise<void> => {
 				if (periodFieldRef.value) {
-					const isValid = periodFieldRef.value.validateOnSubmit()
+					const isValid = await periodFieldRef.value.validateOnSubmit()
 					if (isValid) {
 						formStatus.value = 'Formulaire soumis avec succès !'
 						isFormSubmitted.value = true

package/src/components/PeriodField/PeriodField.vue

@@ -11,51 +11,51 @@
 	type PeriodValue = { from: DateInput, to: DateInput }
 
 	const props = withDefaults(defineProps<{
+		bgColor?: string
+		customRules?: ValidationRule[]
+		customWarningRules?: ValidationRule[]
+		dateFormatReturn?: string
+		density?: 'default' | 'comfortable' | 'compact'
+		disableErrorHandling?: boolean
+		disabled?: boolean
+		displayAppendIcon?: boolean
+		displayIcon?: boolean
+		format?: string
+		headingLevel?: 1 | 2 | 3 | 4 | 5 | 6
+		hideDetails?: boolean | 'auto'
+		isOutlined?: boolean
 		modelValue?: PeriodValue
+		noCalendar?: boolean
+		noIcon?: boolean
 		placeholderFrom?: string
 		placeholderTo?: string
-		format?: string
-		dateFormatReturn?: string
-		showWeekNumber?: boolean
+		readonly?: boolean
 		required?: boolean
-		displayIcon?: boolean
-		displayAppendIcon?: boolean
-		disabled?: boolean
-		noIcon?: boolean
-		noCalendar?: boolean
-		isOutlined?: boolean
 		showSuccessMessages?: boolean
-		customRules?: ValidationRule[]
-		customWarningRules?: ValidationRule[]
-		disableErrorHandling?: boolean
-		readonly?: boolean
-		bgColor?: string
-		density?: 'default' | 'comfortable' | 'compact'
-		hideDetails?: boolean | 'auto'
-		headingLevel?: 1 | 2 | 3 | 4 | 5 | 6
+		showWeekNumber?: boolean
 	}>(), {
+		bgColor: 'white',
+		customRules: () => [],
+		customWarningRules: () => [],
+		dateFormatReturn: '',
+		density: 'default',
+		disableErrorHandling: false,
+		disabled: false,
+		displayAppendIcon: false,
+		displayIcon: true,
+		format: 'DD/MM/YYYY',
+		headingLevel: 2,
+		hideDetails: false,
+		isOutlined: true,
 		modelValue: () => ({ from: null, to: null }),
+		noCalendar: false,
+		noIcon: false,
 		placeholderFrom: 'Début',
 		placeholderTo: 'Fin',
-		format: 'DD/MM/YYYY',
-		dateFormatReturn: '',
-		showWeekNumber: false,
+		readonly: false,
 		required: false,
-		displayIcon: true,
-		displayAppendIcon: false,
-		disabled: false,
-		noIcon: false,
-		noCalendar: false,
-		isOutlined: true,
 		showSuccessMessages: true,
-		customRules: () => [],
-		customWarningRules: () => [],
-		disableErrorHandling: false,
-		readonly: false,
-		bgColor: 'white',
-		density: 'default',
-		hideDetails: false,
-		headingLevel: 2,
+		showWeekNumber: false,
 	})
 
 	const emit = defineEmits(['update:modelValue'])
@@ -230,42 +230,42 @@
 	})
 
 	// Synchronisation lorsque l'une des dates change
-	function validateBothDates() {
+	async function validateBothDates() {
 		if (fromDateRef.value) {
 			fromDateRef.value.validateOnSubmit()
 		}
 		if (toDateRef.value) {
-			toDateRef.value.validateOnSubmit()
+			await toDateRef.value.validateOnSubmit()
 		}
 	}
 
 	// Validation complète du PeriodField
-	function validateFields() {
-		fromDateValidation.validateField(parsedFromDate.value, fromDateRules.value, props.customWarningRules)
-		toDateValidation.validateField(parsedToDate.value, toDateRules.value, props.customWarningRules)
+	async function validateFields() {
+		await fromDateValidation.validateField(parsedFromDate.value, fromDateRules.value, props.customWarningRules)
+		await toDateValidation.validateField(parsedToDate.value, toDateRules.value, props.customWarningRules)
 	}
 
 	// Gestionnaires d'événements closed
-	function handleFromDateClosed() {
-		validateBothDates()
+	async function handleFromDateClosed() {
+		await validateBothDates()
 	}
 
-	function handleToDateClosed() {
-		validateBothDates()
+	async function handleToDateClosed() {
+		await validateBothDates()
 	}
 
 	// Watch pour les changements des dates - validation croisée
-	watch(formattedFromDate, () => {
-		validateFields()
+	watch(formattedFromDate, async () => {
+		await validateFields()
 		if (formattedToDate.value && toDateRef.value) {
-			toDateRef.value.validateOnSubmit()
+			await toDateRef.value.validateOnSubmit()
 		}
 	})
 
-	watch(formattedToDate, () => {
-		validateFields()
+	watch(formattedToDate, async () => {
+		await validateFields()
 		if (formattedFromDate.value && fromDateRef.value) {
-			fromDateRef.value.validateOnSubmit()
+			await fromDateRef.value.validateOnSubmit()
 		}
 	})
 
@@ -278,7 +278,7 @@
 	})
 
 	// Watch pour les changements externes - Synchronisation
-	watch(() => props.modelValue, (newValue) => {
+	watch(() => props.modelValue, async (newValue) => {
 		if (!newValue) return
 
 		const newFromDate = formatDateValue(newValue.from)
@@ -291,28 +291,28 @@
 			internalToDate.value = newToDate
 		}
 		// Valider les champs après la mise à jour des valeurs
-		validateFields()
+		await validateFields()
 	}, { deep: true, immediate: true })
 
 	// Fonction publique de validation
-	const validateOnSubmit = (): boolean => {
+	const validateOnSubmit = async (): Promise<boolean> => {
 		// Valider les deux CalendarMode
-		const fromDateValid = fromDateRef.value?.validateOnSubmit() ?? true
-		const toDateValid = toDateRef.value?.validateOnSubmit() ?? true
+		const fromDateValid = await fromDateRef.value?.validateOnSubmit() ?? true
+		const toDateValid = await toDateRef.value?.validateOnSubmit() ?? true
 
 		// Valider avec les règles personnalisées
-		validateFields()
+		await validateFields()
 
 		// Retourner true seulement si tout est valide
 		return fromDateValid && toDateValid && isValid.value
 	}
 
 	// Initialisation
-	onMounted(() => {
+	onMounted(async () => {
 		internalFromDate.value = formatDateValue(props.modelValue?.from)
 		internalToDate.value = formatDateValue(props.modelValue?.to)
 		// Validation initiale
-		validateFields()
+		await validateFields()
 	})
 
 	defineExpose({

package/src/components/PeriodField/__tests__/PeriodField.async.spec.ts

@@ -0,0 +1,32 @@
+import { mount, flushPromises } from '@vue/test-utils'
+import PeriodField from '../PeriodField.vue'
+import { describe, it, expect } from 'vitest'
+import { nextTick } from 'vue'
+
+describe('PeriodField async validation', () => {
+	it('shows error when from date is after to date', async () => {
+		const wrapper = mount(PeriodField, {
+			props: {
+				modelValue: { from: '2024-01-01', to: '2024-01-31' },
+			},
+		})
+
+		// Find both DatePicker components
+		const datePickers = wrapper.findAllComponents({ name: 'DatePicker' })
+		expect(datePickers.length).toBe(2)
+
+		const fromInput = datePickers[0]!.find('input')
+		await fromInput.setValue('15/01/2024')
+		await fromInput.trigger('blur')
+		await flushPromises()
+
+		const toInput = datePickers[1]!.find('input')
+		await toInput.setValue('10/01/2024')
+		await toInput.trigger('blur')
+		await flushPromises()
+		await nextTick()
+
+		expect(datePickers[0]?.text()).toContain('date de début ne peut pas être supérieure à la date de fin')
+		expect(datePickers[1]?.text()).toContain('La date de fin ne peut pas être inférieure à la date de début')
+	})
+})