Merge pull request 'feat(transport) : saisie assistée QUALIMAT + champs conditionnels (ERP-166)' (#123) from feat/erp-166-qualimat-search into develop

frontend/i18n/locales/fr.json

@@ -526,7 +526,12 @@
             "toast": {
                 "error": "Une erreur est survenue. Réessayez.",
                 "exportError": "L'export du répertoire transporteurs a échoué. Réessayez.",
-                "createSuccess": "Transporteur créé avec succès"
+                "createSuccess": "Transporteur créé avec succès",
+                "integrateSuccess": "Transporteur QUALIMAT intégré"
+            },
+            "containerType": {
+                "BENNE": "Benne",
+                "FOND_MOUVANT": "Fond mouvant"
             },
             "tab": {
                 "qualimat": "Qualimat",
@@ -543,10 +548,36 @@
                 "main": {
                     "name": "Nom",
                     "certificationType": "Certification transport",
-                    "isChartered": "Affréter"
+                    "isChartered": "Affréter",
+                    "indexationRate": "Indexation %",
+                    "containerType": "Benne / Fond mouvant",
+                    "volumeM3": "Volume m³",
+                    "discharge": "Décharge",
+                    "liotPlates": "Immatriculations LIOT",
+                    "liotPlatesHint": "Séparées par « ; »"
+                },
+                "qualimat": {
+                    "empty": "Aucun transporteur QUALIMAT trouvé.",
+                    "searchHint": "Saisissez le nom du transporteur pour lancer la recherche.",
+                    "columns": {
+                        "name": "Nom",
+                        "address": "Adresse",
+                        "validityDate": "Date de validité"
+                    },
+                    "confirm": {
+                        "title": "Intégration QUALIMAT",
+                        "message": "Êtes-vous sûr de vouloir intégrer ce transporteur ?",
+                        "cancel": "Annuler",
+                        "confirm": "Intégrer"
+                    }
                 },
                 "errors": {
-                    "nameRequired": "Le nom du transporteur est obligatoire."
+                    "nameRequired": "Le nom du transporteur est obligatoire.",
+                    "certificationRequired": "Le type de certification est obligatoire.",
+                    "dischargeRequired": "La décharge est obligatoire pour une certification « Autre ».",
+                    "indexationRequired": "Le taux d'indexation est obligatoire pour un transporteur affrété.",
+                    "containerTypeRequired": "Le type de contenant est obligatoire pour un transporteur affrété.",
+                    "volumeRequired": "Le volume est obligatoire pour un transporteur affrété."
                 }
             }
         }

frontend/modules/transport/composables/__tests__/useCarrierForm.test.ts

@@ -65,12 +65,85 @@ describe('useCarrierForm', () => {
         expect(form.mainErrors.errors.name).toBe('transport.carriers.form.errors.nameRequired')
     })
 
+    it('front : certification vide (hors LIOT) → erreur inline sur certificationType, pas de POST', async () => {
+        const form = useCarrierForm()
+        form.main.name = 'Acme'
+        // certificationType laissé null → bloqué côté front (RG-4.01).
+
+        const created = await form.submitMain()
+
+        expect(created).toBe(false)
+        expect(mockPost).not.toHaveBeenCalled()
+        expect(form.mainErrors.errors.certificationType).toBe('transport.carriers.form.errors.certificationRequired')
+    })
+
+    it('front : cas LIOT → certification non requise (aucune erreur de certification)', async () => {
+        mockPost.mockResolvedValueOnce({ id: 5, name: 'LIOT', certificationType: null })
+        const form = useCarrierForm()
+        form.main.name = 'LIOT'
+        form.main.liotPlates = 'AA-123-BB'
+
+        const created = await form.submitMain()
+
+        expect(created).toBe(true)
+        expect(form.mainErrors.errors.certificationType).toBeUndefined()
+    })
+
+    it('front RG-4.02 : certification AUTRE sans décharge → erreur inline, pas de POST', async () => {
+        const form = useCarrierForm()
+        form.main.name = 'Acme'
+        form.main.certificationType = 'AUTRE'
+        // dischargeDocumentIri null (upload non fourni).
+
+        const created = await form.submitMain()
+
+        expect(created).toBe(false)
+        expect(mockPost).not.toHaveBeenCalled()
+        expect(form.mainErrors.errors.dischargeDocument).toBe('transport.carriers.form.errors.dischargeRequired')
+    })
+
+    it('front RG-4.03 : affrété sans indexation / contenant / volume → 3 erreurs inline, pas de POST', async () => {
+        const form = useCarrierForm()
+        form.main.name = 'Acme'
+        form.main.certificationType = 'GMP_PLUS'
+        form.main.isChartered = true
+
+        const created = await form.submitMain()
+
+        expect(created).toBe(false)
+        expect(mockPost).not.toHaveBeenCalled()
+        expect(form.mainErrors.errors.indexationRate).toBe('transport.carriers.form.errors.indexationRequired')
+        expect(form.mainErrors.errors.containerType).toBe('transport.carriers.form.errors.containerTypeRequired')
+        expect(form.mainErrors.errors.volumeM3).toBe('transport.carriers.form.errors.volumeRequired')
+    })
+
+    it('front RG-4.03 : affrété avec tous les champs remplis → POST envoyé', async () => {
+        mockPost.mockResolvedValueOnce({ id: 8, name: 'ACME', certificationType: 'GMP_PLUS' })
+        const form = useCarrierForm()
+        form.main.name = 'Acme'
+        form.main.certificationType = 'GMP_PLUS'
+        form.main.isChartered = true
+        form.main.indexationRate = '5'
+        form.main.containerType = 'BENNE'
+        form.main.volumeM3 = '30'
+
+        const created = await form.submitMain()
+
+        expect(created).toBe(true)
+        expect(mockPost).toHaveBeenCalledTimes(1)
+        expect(mockPost.mock.calls[0]?.[1]).toMatchObject({
+            isChartered: true,
+            indexationRate: '5',
+            containerType: 'BENNE',
+            volumeM3: '30',
+        })
+    })
+
     it('POST /carriers avec Accept ld+json, verrouille et bascule sur Qualimat', async () => {
         mockPost.mockResolvedValueOnce({ id: 42, name: 'TRANSPORTS ACME', certificationType: 'GMP_PLUS' })
         const form = useCarrierForm()
         form.main.name = 'Transports Acme'
         form.main.certificationType = 'GMP_PLUS'
-        form.main.isChartered = true
 
         const created = await form.submitMain()
 
@@ -81,7 +154,7 @@ describe('useCarrierForm', () => {
         expect(body).toEqual({
             name: 'Transports Acme',
             certificationType: 'GMP_PLUS',
-            isChartered: true,
+            isChartered: false,
         })
         expect(opts).toMatchObject({ toast: false, headers: { Accept: 'application/ld+json' } })
 
@@ -89,19 +162,17 @@ describe('useCarrierForm', () => {
         // RG-4.13 : réaffiche le nom normalisé (UPPERCASE) renvoyé par le serveur.
         expect(form.main.name).toBe('TRANSPORTS ACME')
         expect(form.mainLocked.value).toBe(true)
-        expect(form.activeTab.value).toBe('qualimat')
+        // L'onglet Qualimat était déjà accessible (saisie assistée) ; le POST
-        expect(form.unlockedIndex.value).toBe(0)
+        // déverrouille Adresses (index 1) et bascule dessus.
+        expect(form.activeTab.value).toBe('addresses')
+        expect(form.unlockedIndex.value).toBe(1)
     })
 
-    it('payload : omet name et certificationType vides, garde isChartered', async () => {
+    it('buildMainPayload : omet certificationType vide, garde isChartered', () => {
-        mockPost.mockRejectedValueOnce({ response: { status: 422, _data: { violations: [] } } })
         const form = useCarrierForm()
-        form.main.name = 'X' // nom présent pour passer le pré-check front
+        form.main.name = 'X'
-        // certificationType laissé null → omis pour que la 422 « obligatoire » porte.
 
-        await form.submitMain()
+        const body = form.buildMainPayload()
-
-        const body = mockPost.mock.calls[0]?.[1] as Record<string, unknown>
         expect(body).toEqual({ name: 'X', isChartered: false })
         expect('certificationType' in body).toBe(false)
     })
@@ -110,7 +181,7 @@ describe('useCarrierForm', () => {
         mockPost.mockRejectedValueOnce({ response: { status: 409 } })
         const form = useCarrierForm()
         form.main.name = 'Doublon'
-        form.main.certificationType = 'AUTRE'
+        form.main.certificationType = 'GMP_PLUS'
 
         const created = await form.submitMain()
 
@@ -120,19 +191,23 @@ describe('useCarrierForm', () => {
     })
 
     it('422 : mappe les violations serveur inline par champ', async () => {
+        // Contrainte re-validée uniquement back (ex. longueur du nom) : le pré-check
+        // front passe (nom rempli, certif choisie, non affrété), la 422 mappe inline
+        // sur le champ via son propertyPath.
         mockPost.mockRejectedValueOnce({
             response: {
                 status: 422,
-                _data: { violations: [{ propertyPath: 'certificationType', message: 'Le type de certification est obligatoire.' }] },
+                _data: { violations: [{ propertyPath: 'name', message: 'Le nom du transporteur ne peut dépasser 255 caractères.' }] },
             },
         })
         const form = useCarrierForm()
-        form.main.name = 'Sans Certif'
+        form.main.name = 'Acme'
+        form.main.certificationType = 'GMP_PLUS'
 
         const created = await form.submitMain()
 
         expect(created).toBe(false)
-        expect(form.mainErrors.errors.certificationType).toBe('Le type de certification est obligatoire.')
+        expect(form.mainErrors.errors.name).toBe('Le nom du transporteur ne peut dépasser 255 caractères.')
         expect(form.mainLocked.value).toBe(false)
     })
 
@@ -140,8 +215,9 @@ describe('useCarrierForm', () => {
         expect(CARRIER_TAB_KEYS).toEqual(['qualimat', 'addresses', 'contacts', 'prices'])
         const form = useCarrierForm()
         expect(form.tabKeys.value).toEqual(['qualimat', 'addresses', 'contacts', 'prices'])
-        // Tous verrouillés tant que le formulaire principal n'est pas validé.
+        // L'onglet Qualimat (index 0) est accessible dès le départ (saisie assistée) ;
-        expect(form.unlockedIndex.value).toBe(-1)
+        // Adresses / Contacts / Prix restent verrouillés jusqu'au POST principal.
+        expect(form.unlockedIndex.value).toBe(0)
     })
 
     it('completeTab : déverrouille/avance, et signale le dernier onglet du flux', () => {
@@ -189,3 +265,170 @@ describe('useCarrierForm', () => {
         expect(mockPatch).toHaveBeenCalledWith('/carriers/9', { liotPlates: 'AA-123-BB' }, { toast: false })
     })
 })
+
+describe('useCarrierForm — champs conditionnels (ERP-166)', () => {
+    beforeEach(() => {
+        mockPost.mockReset()
+        mockPatch.mockReset()
+    })
+
+    it('cas LIOT (insensible à la casse) : masque la certification, payload réduit', () => {
+        const form = useCarrierForm()
+        form.main.name = 'liot'
+
+        expect(form.isLiot.value).toBe(true)
+        expect(form.showCertification.value).toBe(false)
+
+        form.main.liotPlates = 'AA-123-BB ; CC-456-DD'
+        expect(form.buildMainPayload()).toEqual({
+            name: 'liot',
+            isChartered: false,
+            liotPlates: 'AA-123-BB ; CC-456-DD',
+        })
+    })
+
+    it('LIOT masque les champs conditionnels (affrètement / décharge)', () => {
+        const form = useCarrierForm()
+        form.main.name = 'LIOT'
+        form.main.isChartered = true
+        form.main.certificationType = 'AUTRE'
+
+        expect(form.showCharteredFields.value).toBe(false)
+        expect(form.showDischarge.value).toBe(false)
+    })
+
+    it('RG-4.03 affrété : indexation / contenant / volume visibles et dans le payload', () => {
+        const form = useCarrierForm()
+        form.main.name = 'Acme'
+        form.main.certificationType = 'GMP_PLUS'
+        form.main.isChartered = true
+
+        expect(form.showCharteredFields.value).toBe(true)
+
+        form.main.indexationRate = '5'
+        form.main.containerType = 'BENNE'
+        form.main.volumeM3 = '30'
+
+        expect(form.buildMainPayload()).toEqual({
+            name: 'Acme',
+            certificationType: 'GMP_PLUS',
+            isChartered: true,
+            indexationRate: '5',
+            containerType: 'BENNE',
+            volumeM3: '30',
+        })
+    })
+
+    it('RG-4.03 affrété mais champs vides : omis du payload (422 NotBlank back)', () => {
+        const form = useCarrierForm()
+        form.main.name = 'Acme'
+        form.main.certificationType = 'GMP_PLUS'
+        form.main.isChartered = true
+
+        expect(form.buildMainPayload()).toEqual({
+            name: 'Acme',
+            certificationType: 'GMP_PLUS',
+            isChartered: true,
+        })
+    })
+
+    it('RG-4.02 AUTRE : décharge visible + dischargeDocument dans le payload si IRI résolu', () => {
+        const form = useCarrierForm()
+        form.main.name = 'Acme'
+        form.main.certificationType = 'AUTRE'
+
+        expect(form.showDischarge.value).toBe(true)
+
+        form.main.dischargeDocumentIri = '/api/uploaded_documents/7'
+        expect(form.buildMainPayload()).toMatchObject({ dischargeDocument: '/api/uploaded_documents/7' })
+    })
+})
+
+describe('useCarrierForm — copie QUALIMAT (ERP-166)', () => {
+    const QUALIMAT_ROW = {
+        '@id': '/api/qualimat_carriers/42',
+        id: '42',
+        name: 'TRANSPORTS QUALIMAT',
+        siret: '12345678900012',
+        address: '1 rue du Port',
+        postalCode: '86000',
+        city: 'Poitiers',
+        validityDate: '2027-01-15',
+        status: 'VALIDE',
+    }
+
+    beforeEach(() => {
+        mockPost.mockReset()
+        mockPatch.mockReset()
+    })
+
+    it('copie name + certificationType=QUALIMAT (readonly) + IRI + adresse, sans PATCH avant création', async () => {
+        const form = useCarrierForm()
+
+        const ok = await form.applyQualimatSelection(QUALIMAT_ROW)
+
+        expect(ok).toBe(true)
+        expect(mockPatch).not.toHaveBeenCalled()
+        expect(form.main.name).toBe('TRANSPORTS QUALIMAT')
+        expect(form.main.certificationType).toBe('QUALIMAT')
+        expect(form.main.qualimatCarrierIri).toBe('/api/qualimat_carriers/42')
+        expect(form.isQualimat.value).toBe(true)
+        expect(form.certificationReadonly.value).toBe(true)
+        expect(form.qualimatAddress.value).toEqual({
+            country: 'France',
+            postalCode: '86000',
+            city: 'Poitiers',
+            street: '1 rue du Port',
+        })
+    })
+
+    it('après création : PATCH /carriers/{id} avec qualimatCarrier + name + certification', async () => {
+        mockPost.mockResolvedValueOnce({ id: 9, name: 'X', certificationType: 'GMP_PLUS' })
+        mockPatch.mockResolvedValueOnce({})
+        const form = useCarrierForm()
+        form.main.name = 'X'
+        form.main.certificationType = 'GMP_PLUS'
+        await form.submitMain()
+
+        const ok = await form.applyQualimatSelection(QUALIMAT_ROW)
+
+        expect(ok).toBe(true)
+        expect(mockPatch).toHaveBeenCalledWith(
+            '/carriers/9',
+            {
+                qualimatCarrier: '/api/qualimat_carriers/42',
+                name: 'TRANSPORTS QUALIMAT',
+                certificationType: 'QUALIMAT',
+            },
+            { toast: false },
+        )
+    })
+
+    it('après création : PATCH en échec → pas de copie locale (rollback) et retour false', async () => {
+        mockPost.mockResolvedValueOnce({ id: 9, name: 'X', certificationType: 'GMP_PLUS' })
+        mockPatch.mockRejectedValueOnce({ response: { status: 500, _data: {} } })
+        const form = useCarrierForm()
+        form.main.name = 'X'
+        form.main.certificationType = 'GMP_PLUS'
+        await form.submitMain()
+
+        const ok = await form.applyQualimatSelection(QUALIMAT_ROW)
+
+        // Échec serveur : l'UI ne doit pas refléter une intégration QUALIMAT non persistée.
+        expect(ok).toBe(false)
+        expect(form.main.name).toBe('X')
+        expect(form.main.certificationType).toBe('GMP_PLUS')
+        expect(form.main.qualimatCarrierIri).toBeNull()
+    })
+
+    it('buildMainPayload inclut qualimatCarrier + certificationType QUALIMAT après intégration', async () => {
+        const form = useCarrierForm()
+        form.main.name = 'Acme'
+        await form.applyQualimatSelection(QUALIMAT_ROW)
+
+        expect(form.buildMainPayload()).toMatchObject({
+            qualimatCarrier: '/api/qualimat_carriers/42',
+            certificationType: 'QUALIMAT',
+        })
+    })
+})

frontend/modules/transport/composables/__tests__/useQualimatSearch.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { useQualimatSearch, type QualimatCarrierRow } from '../useQualimatSearch'
+
+const mockApiGet = vi.hoisted(() => vi.fn())
+vi.stubGlobal('useApi', () => ({ get: mockApiGet }))
+
+/**
+ * Tests de la saisie assistée QUALIMAT (M4 Transport, ERP-166 — RG-4.01).
+ *
+ * `useQualimatSearch` est une fine enveloppe de `usePaginatedList<QualimatCarrierRow>`
+ * sur `/qualimat_carriers`. La pagination générique est couverte par
+ * `usePaginatedList.test.ts` ; on vérifie ici le CONTRAT propre à la recherche :
+ *  - ressource ciblée `/qualimat_carriers` + enveloppe Hydra + `Accept: application/ld+json` ;
+ *  - le filtre `search` (branché sur le nom du transporteur) est transmis et
+ *    retombe en page 1.
+ */
+describe('useQualimatSearch', () => {
+    beforeEach(() => {
+        mockApiGet.mockReset()
+    })
+
+    const PAGE: QualimatCarrierRow[] = [
+        {
+            '@id': '/api/qualimat_carriers/1',
+            id: '1',
+            name: 'TRANSPORTS ACME',
+            siret: '12345678900012',
+            address: '1 rue du Port',
+            postalCode: '86000',
+            city: 'Poitiers',
+            validityDate: '2027-01-15',
+            status: 'VALIDE',
+        },
+    ]
+
+    it('cible /qualimat_carriers, consomme l\'enveloppe Hydra et envoie l\'Accept ld+json', async () => {
+        mockApiGet.mockResolvedValueOnce({ member: PAGE, totalItems: 1 })
+        const repo = useQualimatSearch()
+
+        await repo.fetch()
+
+        const [url, query, opts] = mockApiGet.mock.calls[0]
+        expect(url).toBe('/qualimat_carriers')
+        expect(query).toMatchObject({ page: 1, itemsPerPage: 10 })
+        expect(opts).toMatchObject({ toast: false, headers: { Accept: 'application/ld+json' } })
+        expect(repo.items.value).toEqual(PAGE)
+        expect(repo.totalItems.value).toBe(1)
+    })
+
+    it('transmet le filtre `search` (nom du transporteur) et retombe en page 1', async () => {
+        mockApiGet.mockResolvedValueOnce({ member: PAGE, totalItems: 1 })
+        const repo = useQualimatSearch()
+        await repo.fetch()
+
+        mockApiGet.mockResolvedValueOnce({ member: PAGE, totalItems: 1 })
+        await repo.setFilters({ search: 'acme' })
+
+        expect(repo.currentPage.value).toBe(1)
+        const query = mockApiGet.mock.calls.at(-1)?.[1] as Record<string, unknown>
+        expect(query.search).toBe('acme')
+    })
+})

frontend/modules/transport/composables/useCarrierForm.ts

@@ -1,10 +1,16 @@
-import { reactive, ref } from 'vue'
+import { computed, reactive, ref } from 'vue'
 import { useFormErrors } from '~/shared/composables/useFormErrors'
 import {
+    emptyCarrierAddressCopy,
     emptyCarrierMain,
+    type CarrierAddressCopy,
     type CarrierMainDraft,
     type CarrierMainResponse,
 } from '~/modules/transport/types/carrierForm'
+import type { QualimatCarrierRow } from '~/modules/transport/composables/useQualimatSearch'
+
+/** Nom du cas spécial « compte-propre » LIOT (comparaison insensible à la casse, RG-4.01). */
+const LIOT_NAME = 'LIOT'
 
 /**
  * Workflow de l'écran « Ajouter un transporteur » (M4 Transport, ERP-165) —
@@ -50,10 +56,30 @@ export function useCarrierForm() {
     // ── Formulaire principal ──────────────────────────────────────────────────
     const main = reactive<CarrierMainDraft>(emptyCarrierMain())
 
+    // Adresse copiée depuis QUALIMAT à la sélection (alimente l'onglet Adresses,
+    // ticket ultérieur). Vide tant qu'aucun transporteur QUALIMAT n'est intégré.
+    const qualimatAddress = ref<CarrierAddressCopy>(emptyCarrierAddressCopy())
+
+    // ── Affichage conditionnel du formulaire principal (RG-4.01 / 4.02 / 4.03) ──
+    // Cas LIOT : nom == « LIOT » → seul `liotPlates` est pertinent, le reste masqué.
+    const isLiot = computed(() => main.name.trim().toUpperCase() === LIOT_NAME)
+    // Transporteur QUALIMAT : la FK est posée → certification figée à « QUALIMAT ».
+    const isQualimat = computed(() => main.qualimatCarrierIri !== null)
+    // Certification masquée en cas LIOT ; lecture seule si QUALIMAT (ou bloc verrouillé).
+    const showCertification = computed(() => !isLiot.value)
+    const certificationReadonly = computed(() => isQualimat.value || mainLocked.value)
+    // RG-4.03 : champs d'affrètement (indexation / contenant / volume) visibles et
+    // obligatoires si « Affréter » coché — masqués en cas LIOT.
+    const showCharteredFields = computed(() => main.isChartered && !isLiot.value)
+    // RG-4.02 : décharge visible et obligatoire si certification == AUTRE (hors LIOT).
+    const showDischarge = computed(() => main.certificationType === 'AUTRE' && !isLiot.value)
+
     // ── Onglets : ordre + gating progressif ───────────────────────────────────
     const tabKeys = ref<string[]>([...CARRIER_TAB_KEYS])
-    // Index du dernier onglet déverrouillé (-1 tant que le transporteur n'est pas créé).
+    // Index du dernier onglet déverrouillé. L'onglet Qualimat (index 0) est la saisie
-    const unlockedIndex = ref(-1)
+    // assistée du formulaire principal : accessible DÈS LE DÉPART (≠ Adresses /
+    // Contacts / Prix, déverrouillés seulement après le POST principal).
+    const unlockedIndex = ref(0)
     const activeTab = ref<string>(CARRIER_TAB_KEYS[0])
     // Onglets validés (passent en lecture seule).
     const validated = reactive<Record<string, boolean>>({})
@@ -71,10 +97,11 @@ export function useCarrierForm() {
 
     /**
      * Validation FRONT du formulaire principal : seul le nom est requis côté front
-     * (RG-4.01). Le back reste la couche autoritaire (ERP-101) — la certification
+     * (ERP-101) : feedback immédiat sur tous les champs obligatoires (y compris
-     * obligatoire (sauf LIOT) et les RG conditionnelles sont re-validées serveur et
+     * conditionnels), alignés sur les RG du back (qui reste autoritaire) :
-     * remontées en 422 inline, sans pré-check front (qui devrait connaître le cas
+     *  - RG-4.01 : nom requis ; certification requise hors cas LIOT (où tout est masqué) ;
-     * LIOT, hors périmètre ERP-165).
+     *  - RG-4.02 : décharge requise si certification AUTRE ;
+     *  - RG-4.03 : indexation + contenant + volume requis si « Affréter ».
      */
     function validateMainFront(): boolean {
         let valid = true
@@ -82,6 +109,40 @@ export function useCarrierForm() {
             mainErrors.setError('name', t('transport.carriers.form.errors.nameRequired'))
             valid = false
         }
+
+        // Cas LIOT : seul le nom compte, les autres champs sont masqués (RG-4.01).
+        if (isLiot.value) {
+            return valid
+        }
+
+        // RG-4.01 : certification obligatoire hors LIOT.
+        if (!main.certificationType) {
+            mainErrors.setError('certificationType', t('transport.carriers.form.errors.certificationRequired'))
+            valid = false
+        }
+
+        // RG-4.02 : décharge obligatoire si certification AUTRE.
+        if (main.certificationType === 'AUTRE' && !main.dischargeDocumentIri) {
+            mainErrors.setError('dischargeDocument', t('transport.carriers.form.errors.dischargeRequired'))
+            valid = false
+        }
+
+        // RG-4.03 : indexation / contenant / volume obligatoires si affrété.
+        if (main.isChartered) {
+            if (!main.indexationRate.trim()) {
+                mainErrors.setError('indexationRate', t('transport.carriers.form.errors.indexationRequired'))
+                valid = false
+            }
+            if (!main.containerType) {
+                mainErrors.setError('containerType', t('transport.carriers.form.errors.containerTypeRequired'))
+                valid = false
+            }
+            if (!main.volumeM3.trim()) {
+                mainErrors.setError('volumeM3', t('transport.carriers.form.errors.volumeRequired'))
+                valid = false
+            }
+        }
+
         return valid
     }
 
@@ -92,22 +153,53 @@ export function useCarrierForm() {
      * certification) sur le champ plutôt qu'une erreur de type.
      */
     function buildMainPayload(): Record<string, unknown> {
-        const payload: Record<string, unknown> = {
+        // Cas LIOT (RG-4.01) : seul `liotPlates` est pertinent ; les autres champs
-            isChartered: main.isChartered,
+        // sont masqués côté front et non envoyés (le back stocke ce qu'il reçoit).
+        if (isLiot.value) {
+            const payload: Record<string, unknown> = { name: main.name, isChartered: false }
+            if (main.liotPlates.trim()) {
+                payload.liotPlates = main.liotPlates
+            }
+            return payload
         }
-        if (main.name?.trim()) {
+
+        const payload: Record<string, unknown> = { isChartered: main.isChartered }
+        if (main.name.trim()) {
             payload.name = main.name
         }
         if (main.certificationType) {
             payload.certificationType = main.certificationType
         }
+        // FK QUALIMAT (saisie assistée, § 2.5) envoyée si une ligne a été intégrée.
+        if (main.qualimatCarrierIri) {
+            payload.qualimatCarrier = main.qualimatCarrierIri
+        }
+        // RG-4.02 : décharge envoyée seulement en certification AUTRE ; omise quand
+        // absente pour que la 422 « obligatoire » porte sur le champ.
+        if (main.certificationType === 'AUTRE' && main.dischargeDocumentIri) {
+            payload.dischargeDocument = main.dischargeDocumentIri
+        }
+        // RG-4.03 : indexation / contenant / volume envoyés seulement si affrété ;
+        // omis quand vides pour déclencher la 422 NotBlank inline sur le champ.
+        if (main.isChartered) {
+            if (main.indexationRate.trim()) {
+                payload.indexationRate = main.indexationRate
+            }
+            if (main.containerType) {
+                payload.containerType = main.containerType
+            }
+            if (main.volumeM3.trim()) {
+                payload.volumeM3 = main.volumeM3
+            }
+        }
         return payload
     }
 
     /**
-     * POST /carriers (groupe `carrier:write:main`). Pré-check front (nom), puis
+     * POST /carriers (groupe `carrier:write:main`). Pré-check front, puis création.
-     * création. Au succès : verrouille le bloc principal, déverrouille le 1er onglet
+     * Au succès : verrouille le bloc principal, déverrouille l'onglet Adresses et
-     * et bascule sur « Qualimat ». Retourne true si créé, false sinon.
+     * bascule dessus (l'onglet Qualimat, saisie assistée, était déjà accessible).
+     * Retourne true si créé, false sinon.
      */
     async function submitMain(): Promise<boolean> {
         if (mainSubmitting.value) return false
@@ -128,8 +220,9 @@ export function useCarrierForm() {
             main.certificationType = created.certificationType ?? main.certificationType
 
             mainLocked.value = true
-            unlockedIndex.value = 0
+            // Déverrouille l'onglet suivant (Adresses, index 1) et bascule dessus.
-            activeTab.value = tabKeys.value[0] ?? CARRIER_TAB_KEYS[0]
+            unlockedIndex.value = Math.max(unlockedIndex.value, 1)
+            activeTab.value = tabKeys.value[1] ?? CARRIER_TAB_KEYS[1]
             toast.success({ title: t('transport.carriers.toast.createSuccess') })
             return true
         }
@@ -162,6 +255,44 @@ export function useCarrierForm() {
         await api.patch(`/carriers/${carrierId.value}`, payload, { toast: false })
     }
 
+    /**
+     * Intègre une ligne QUALIMAT sélectionnée dans l'onglet Qualimat (RG-4.01 /
+     * § 2.5) : copie le nom, force la certification à « QUALIMAT » (lecture seule),
+     * pose la FK `qualimatCarrier` (IRI) et copie l'adresse (pour l'onglet Adresses).
+     * Si le transporteur existe déjà (post-POST, cas nominal de l'onglet), persiste
+     * d'abord la copie via un PATCH partiel `carrier:write:main` : la copie locale
+     * (nom, certification figée « QUALIMAT », FK, adresse) n'est appliquée qu'en cas
+     * de succès, pour ne pas laisser l'UI dans un état QUALIMAT non sauvegardé si le
+     * PATCH échoue. Retourne true si l'intégration a abouti.
+     */
+    async function applyQualimatSelection(row: QualimatCarrierRow): Promise<boolean> {
+        // Transporteur déjà créé : on persiste avant de refléter localement.
+        if (carrierId.value !== null) {
+            try {
+                await patchCarrier({
+                    qualimatCarrier: row['@id'],
+                    name: row.name,
+                    certificationType: 'QUALIMAT',
+                })
+            }
+            catch (error) {
+                mainErrors.handleApiError(error, { fallbackMessage: t('transport.carriers.toast.error') })
+                return false
+            }
+        }
+
+        main.name = row.name ?? ''
+        main.certificationType = 'QUALIMAT'
+        main.qualimatCarrierIri = row['@id']
+        qualimatAddress.value = {
+            country: 'France',
+            postalCode: row.postalCode ?? '',
+            city: row.city ?? '',
+            street: row.address ?? '',
+        }
+        return true
+    }
+
     /**
      * Marque un onglet validé (passe en lecture seule), déverrouille et avance à
      * l'onglet suivant. Retourne true si c'était le dernier onglet du flux (création
@@ -186,10 +317,18 @@ export function useCarrierForm() {
     return {
         // état
         main,
+        qualimatAddress,
         carrierId,
         mainLocked,
         mainSubmitting,
         mainErrors,
+        // affichage conditionnel
+        isLiot,
+        isQualimat,
+        showCertification,
+        certificationReadonly,
+        showCharteredFields,
+        showDischarge,
         // onglets
         tabKeys,
         activeTab,
@@ -202,6 +341,7 @@ export function useCarrierForm() {
         buildMainPayload,
         submitMain,
         patchCarrier,
+        applyQualimatSelection,
         completeTab,
     }
 }

frontend/modules/transport/composables/useQualimatSearch.ts

@@ -0,0 +1,40 @@
+import { usePaginatedList } from '~/shared/composables/usePaginatedList'
+
+/**
+ * Ligne du référentiel QUALIMAT renvoyée par la saisie assistée (groupe
+ * `qualimat:read`). `@id` est l'IRI conservée comme FK `carrier.qualimatCarrier`
+ * (RG-4.01 / § 2.5) ; `validityDate` pilote le fond rouge de la colonne « Date de
+ * validité » (RG-4.04).
+ */
+export interface QualimatCarrierRow {
+    '@id': string
+    id: string
+    name: string | null
+    siret: string | null
+    address: string | null
+    postalCode: string | null
+    city: string | null
+    validityDate: string | null
+    status: string | null
+}
+
+/** Filtre de la recherche QUALIMAT (branché sur le nom du transporteur). */
+export interface QualimatSearchFilters {
+    search?: string
+}
+
+/**
+ * Saisie assistée QUALIMAT (M4 Transport, ERP-166 — RG-4.01 / spec-back § 4.7).
+ *
+ * `GET /api/qualimat_carriers?search=` : référentiel en LECTURE SEULE, lignes
+ * actives uniquement (filtré côté serveur), recherche fuzzy nom + siret. Simple
+ * enveloppe de `usePaginatedList` (règle frontend : toute GetCollection passe par
+ * ce composable — pagination Hydra, état 100 % local) consommée par le
+ * `MalioDataTable` de l'onglet Qualimat. Le filtre `search` est piloté par le nom
+ * saisi dans le formulaire principal (pas de champ de recherche dédié).
+ *
+ * Volontairement PAR INSTANCE (état local à l'écran d'ajout).
+ */
+export function useQualimatSearch() {
+    return usePaginatedList<QualimatCarrierRow, QualimatSearchFilters>({ url: '/qualimat_carriers' })
+}

frontend/modules/transport/pages/carriers/new.vue

@@ -13,11 +13,10 @@
         </div>
 
         <!-- ── Formulaire principal (pre-onglets) ─────────────────────────────
-             Sans validation de ce bloc, les onglets restent inaccessibles. Au
+             Champs conditionnels (ERP-166) : cas LIOT (nom == LIOT) → seul
-             succes du POST, les champs passent en lecture seule et on bascule
+             « immatriculations » ; certification AUTRE → champ Decharge ; Affreter
-             automatiquement sur l'onglet Qualimat. Les champs conditionnels
+             coche → indexation / contenant / volume. La certification est en lecture
-             (indexation / benne / volume si affrete, decharge si AUTRE, cas LIOT)
+             seule pour un transporteur QUALIMAT (saisie assistee, onglet Qualimat). -->
-             et la saisie assistee QUALIMAT arrivent a ERP-166. -->
         <div class="mt-[48px] grid grid-cols-3 xl:grid-cols-4 gap-x-[44px] gap-y-4">
             <MalioInputText
                 v-model="main.name"
@@ -26,29 +25,96 @@
                 :readonly="mainLocked"
                 :error="mainErrors.errors.name"
             />
-            <MalioSelect
+
-                :model-value="main.certificationType"
+            <!-- Cas LIOT : seul le champ immatriculations est pertinent. -->
-                :options="certificationOptions"
+            <MalioInputText
-                :label="t('transport.carriers.form.main.certificationType')"
+                v-if="isLiot"
-                empty-option-label=""
+                v-model="main.liotPlates"
+                :label="t('transport.carriers.form.main.liotPlates')"
+                :hint="t('transport.carriers.form.main.liotPlatesHint')"
                 :required="true"
                 :readonly="mainLocked"
-                :error="mainErrors.errors.certificationType"
+                :error="mainErrors.errors.liotPlates"
-                @update:model-value="(v: string | number | null) => main.certificationType = v === null ? null : String(v)"
             />
-            <!-- Wrapper h-12 + centrage vertical : aligne la case a cocher sur la
+
-                 ligne de champ des inputs/selects (qui posent un h-12 items-center
+            <!-- Cas standard : certification + affretement + champs conditionnels. -->
-                 en interne). reserve-message-space=false pour un centrage exact. -->
+            <template v-if="!isLiot">
-            <div class="flex h-12 items-center">
+                <MalioSelect
-                <MalioCheckbox
+                    :model-value="main.certificationType"
-                    id="carrier-is-chartered"
+                    :options="certificationOptions"
-                    :label="t('transport.carriers.form.main.isChartered')"
+                    :label="t('transport.carriers.form.main.certificationType')"
-                    :model-value="main.isChartered"
+                    empty-option-label=""
-                    :readonly="mainLocked"
+                    :required="true"
-                    :reserve-message-space="false"
+                    :readonly="certificationReadonly"
-                    @update:model-value="(val: boolean) => main.isChartered = val"
+                    :error="mainErrors.errors.certificationType"
+                    @update:model-value="(v: string | number | null) => main.certificationType = v === null ? null : String(v)"
                 />
-            </div>
+
+                <!-- Colonne 3 RÉSERVÉE à la Décharge (RG-4.02 : visible et obligatoire
+                     si certification AUTRE). Si elle n'apparaît pas, on garde la colonne
+                     vide (xl) pour qu'« Affréter » reste en colonne 4 de la ligne 1.
+                     L'upload reel (File → IRI via useUpload) arrive a ERP-171. -->
+                <!-- TODO ERP-171 : brancher useUpload pour resoudre le File en IRI
+                     (main.dischargeDocumentIri). Le champ est deja visible/obligatoire. -->
+                <MalioInputUpload
+                    v-if="showDischarge"
+                    :label="t('transport.carriers.form.main.discharge')"
+                    accept="application/pdf,image/*"
+                    :required="true"
+                    :readonly="mainLocked"
+                    :clearable="true"
+                    :error="mainErrors.errors.dischargeDocument"
+                    @clear="main.dischargeDocumentIri = null"
+                />
+                <div v-else class="hidden xl:block"></div>
+
+                <!-- « Affréter » : toujours en colonne 4 de la ligne 1 (colonne 3
+                     réservée à la décharge ci-dessus). Wrapper h-12 + centrage vertical
+                     pour aligner la case sur la ligne de champ des inputs/selects. -->
+                <div class="flex h-12 items-center">
+                    <MalioCheckbox
+                        id="carrier-is-chartered"
+                        :label="t('transport.carriers.form.main.isChartered')"
+                        :model-value="main.isChartered"
+                        :readonly="mainLocked"
+                        :reserve-message-space="false"
+                        @update:model-value="(val: boolean) => main.isChartered = val"
+                    />
+                </div>
+
+                <!-- RG-4.03 : champs d'affretement (ligne 2) visibles + obligatoires si
+                     « Affreter ». La ligne 1 étant pleine (4 colonnes), ils démarrent
+                     naturellement en colonne 1 de la ligne 2. -->
+                <template v-if="showCharteredFields">
+                    <MalioInputNumber
+                        v-model="main.indexationRate"
+                        :label="t('transport.carriers.form.main.indexationRate')"
+                        :required="true"
+                        :readonly="mainLocked"
+                        :error="mainErrors.errors.indexationRate"
+                    />
+
+                    <!-- Contenant : Benne / Fond mouvant (RG-4.03). -->
+                    <MalioSelect
+                        :model-value="main.containerType"
+                        :options="containerOptions"
+                        :label="t('transport.carriers.form.main.containerType')"
+                        empty-option-label=""
+                        :required="true"
+                        :readonly="mainLocked"
+                        :error="mainErrors.errors.containerType"
+                        @update:model-value="(v: string | number | null) => main.containerType = v === null ? null : String(v)"
+                    />
+
+                    <MalioInputNumber
+                        v-model="main.volumeM3"
+                        :label="t('transport.carriers.form.main.volumeM3')"
+                        :required="true"
+                        :readonly="mainLocked"
+                        :error="mainErrors.errors.volumeM3"
+                    />
+                </template>
+            </template>
         </div>
 
         <div v-if="!mainLocked" class="mt-12 flex justify-center">
@@ -61,13 +127,52 @@
         </div>
 
         <!-- ── Onglets a validation incrementale ─────────────────────────────
-             Barre Qualimat · Adresses · Contacts · Prix. Onglets verrouilles tant
+             Barre Qualimat · Adresses · Contacts · Prix. Onglet Qualimat = saisie
-             que le formulaire principal n'est pas valide (unlockedIndex = -1) puis
+             assistee (table de selection) ; Adresses / Contacts / Prix arrivent aux
-             deverrouilles progressivement. Le contenu de chaque onglet arrive aux
+             tickets suivants (placeholders « A venir »). -->
-             tickets suivants (ERP-166+) : placeholders « A venir » pour l'instant. -->
         <MalioTabList v-model="activeTab" :tabs="tabs" class="mt-[60px]">
+            <!-- Onglet Qualimat : datatable paginé filtré par le NOM du transporteur
+                 (pas de champ de recherche dédié — RG-4.01 / 4.04). -->
+            <template #qualimat>
+                <div class="mt-12 flex flex-col gap-6">
+                    <MalioDataTable
+                        :columns="qualimatColumns"
+                        :items="qualimatRows"
+                        :total-items="qualimatTotalDisplay"
+                        :page="qualimatPage"
+                        :per-page="qualimatPerPage"
+                        :per-page-options="qualimatPerPageOptions"
+                        row-clickable
+                        :empty-message="qualimatEmptyMessage"
+                        @row-click="onQualimatRowClick"
+                        @update:page="qualimatGoToPage"
+                        @update:per-page="qualimatSetPerPage"
+                    >
+                        <!-- Radio reflétant la ligne QUALIMAT intégrée (lecture). -->
+                        <template #cell-select="{ item }">
+                            <MalioRadioButton
+                                :model-value="main.qualimatCarrierIri"
+                                name="qualimat-row"
+                                :value="item.iri"
+                                group-class="mt-0"
+                            />
+                        </template>
+                        <!-- Date de validité : fond rouge si périmée (RG-4.04). -->
+                        <template #cell-validityDate="{ item }">
+                            <span
+                                v-if="item.validityDate"
+                                :class="isExpired(item.validityDate as string) ? 'inline-block rounded px-2 py-0.5 bg-m-danger text-white' : ''"
+                            >
+                                {{ formatDateFr(item.validityDate as string) }}
+                            </span>
+                        </template>
+                    </MalioDataTable>
+                </div>
+            </template>
+
+            <!-- Adresses / Contacts / Prix : contenu aux tickets suivants. -->
             <template
-                v-for="key in tabKeys"
+                v-for="key in placeholderTabs"
                 :key="key"
                 #[key]
             >
@@ -76,12 +181,36 @@
                 </div>
             </template>
         </MalioTabList>
+
+        <!-- Modal de confirmation d'integration QUALIMAT (RG-4.01). -->
+        <MalioModal v-model="confirmOpen" modal-class="max-w-md">
+            <template #header>
+                <h2 class="text-[24px] font-bold">{{ t('transport.carriers.form.qualimat.confirm.title') }}</h2>
+            </template>
+            <p>{{ t('transport.carriers.form.qualimat.confirm.message') }}</p>
+            <template #footer>
+                <MalioButton
+                    variant="secondary"
+                    button-class="flex-1"
+                    :label="t('transport.carriers.form.qualimat.confirm.cancel')"
+                    @click="confirmOpen = false"
+                />
+                <MalioButton
+                    variant="primary"
+                    button-class="flex-1"
+                    :label="t('transport.carriers.form.qualimat.confirm.confirm')"
+                    @click="confirmIntegrate"
+                />
+            </template>
+        </MalioModal>
     </div>
 </template>
 
 <script setup lang="ts">
-import { computed } from 'vue'
+import { computed, ref, watch } from 'vue'
+import { debounce } from '~/shared/utils/debounce'
 import { useCarrierForm } from '~/modules/transport/composables/useCarrierForm'
+import { useQualimatSearch, type QualimatCarrierRow } from '~/modules/transport/composables/useQualimatSearch'
 
 interface SelectOption {
     value: string
@@ -90,6 +219,7 @@ interface SelectOption {
 
 const { t } = useI18n()
 const router = useRouter()
+const toast = useToast()
 const { can } = usePermissions()
 
 useHead({ title: t('transport.carriers.form.title') })
@@ -105,21 +235,86 @@ const {
     mainLocked,
     mainSubmitting,
     mainErrors,
+    isLiot,
+    certificationReadonly,
+    showCharteredFields,
+    showDischarge,
     tabKeys,
     activeTab,
     unlockedIndex,
     submitMain,
+    applyQualimatSelection,
 } = useCarrierForm()
 
-// Certifications selectionnables manuellement (spec § Formulaire principal).
+const {
-// QUALIMAT n'est PAS dans cette liste : il est pose par la saisie assistee QUALIMAT
+    items: qualimatItems,
-// (ERP-166), pas choisi a la main.
+    totalItems: qualimatTotal,
+    currentPage: qualimatPage,
+    itemsPerPage: qualimatPerPage,
+    itemsPerPageOptions: qualimatPerPageOptions,
+    goToPage: qualimatGoToPage,
+    setItemsPerPage: qualimatSetPerPage,
+    setFilters: qualimatSetFilters,
+} = useQualimatSearch()
+
+// Certifications selectionnables manuellement (spec § Formulaire principal) :
+// GMP+ / OVOCOM / Compte-propre / Autre. QUALIMAT n'y figure PAS — il est posé par
+// la saisie assistee (onglet Qualimat). On l'ajoute cependant aux options QUAND il
+// est deja selectionne (transporteur QUALIMAT integre), uniquement pour AFFICHER
+// son libelle dans le select en lecture seule.
 const SELECTABLE_CERTIFICATIONS = ['GMP_PLUS', 'OVOCOM', 'COMPTE_PROPRE', 'AUTRE'] as const
 
-const certificationOptions = computed<SelectOption[]>(() =>
+const certificationOptions = computed<SelectOption[]>(() => {
-    SELECTABLE_CERTIFICATIONS.map(code => ({
+    const codes: string[] = [...SELECTABLE_CERTIFICATIONS]
+    if (main.certificationType === 'QUALIMAT') {
+        codes.unshift('QUALIMAT')
+    }
+    return codes.map(code => ({
         value: code,
         label: t(`transport.carriers.certification.${code}`),
+    }))
+})
+
+// Colonnes du datatable de selection QUALIMAT (radio / Nom / Adresse / Validite).
+const qualimatColumns = [
+    { key: 'select', label: '' },
+    { key: 'name', label: t('transport.carriers.form.qualimat.columns.name') },
+    { key: 'address', label: t('transport.carriers.form.qualimat.columns.address') },
+    { key: 'validityDate', label: t('transport.carriers.form.qualimat.columns.validityDate') },
+]
+
+// Le datatable n'affiche QUE des résultats de recherche : vide tant que le Nom n'est
+// pas saisi (pas de liste complète par défaut). `main.name` pilote l'affichage.
+const hasQualimatSearch = computed(() => main.name.trim() !== '')
+
+// Lignes « plates » pour MalioDataTable (l'IRI sert au radio + à retrouver la ligne
+// source au clic). Le détail QUALIMAT complet reste dans `qualimatItems`.
+const qualimatRows = computed(() => {
+    if (!hasQualimatSearch.value) {
+        return []
+    }
+    return qualimatItems.value.map(row => ({
+        id: row.id,
+        iri: row['@id'],
+        name: row.name,
+        address: formatQualimatAddress(row),
+        validityDate: row.validityDate,
+    }))
+})
+
+// Total / message vide alignés sur « tableau vide tant qu'on n'a pas recherché ».
+const qualimatTotalDisplay = computed(() => (hasQualimatSearch.value ? qualimatTotal.value : 0))
+const qualimatEmptyMessage = computed(() => hasQualimatSearch.value
+    ? t('transport.carriers.form.qualimat.empty')
+    : t('transport.carriers.form.qualimat.searchHint'))
+
+// Contenant (RG-4.03) : Benne / Fond mouvant — select simple.
+const CONTAINER_TYPES = ['BENNE', 'FOND_MOUVANT'] as const
+
+const containerOptions = computed<SelectOption[]>(() =>
+    CONTAINER_TYPES.map(code => ({
+        value: code,
+        label: t(`transport.carriers.containerType.${code}`),
     })),
 )
 
@@ -140,12 +335,89 @@ const tabs = computed(() => tabKeys.value.map((key, index) => ({
     disabled: index > unlockedIndex.value,
 })))
 
+// Onglets dont le contenu arrive aux tickets suivants (tout sauf Qualimat).
+const placeholderTabs = computed(() => tabKeys.value.filter(key => key !== 'qualimat'))
+
+// ── Saisie assistee QUALIMAT (onglet Qualimat) ───────────────────────────────
+const confirmOpen = ref(false)
+const pendingRow = ref<QualimatCarrierRow | null>(null)
+
+// Le datatable QUALIMAT est filtré par le NOM saisi dans le formulaire principal
+// (RG-4.01) — pas de champ de recherche dédié. Aucune recherche tant que le Nom est
+// vide (tableau vide par défaut) ; sinon re-filtrage debouncé à chaque frappe.
+const filterQualimatByName = debounce((term: string) => {
+    if (term.trim() === '') {
+        return
+    }
+    void qualimatSetFilters({ search: term })
+}, 300)
+
+watch(() => main.name, term => filterQualimatByName(term))
+
+/** Adresse QUALIMAT condensee pour la colonne « Adresse » (voie · CP · ville). */
+function formatQualimatAddress(row: QualimatCarrierRow): string {
+    return [row.address, row.postalCode, row.city].filter(Boolean).join(' · ')
+}
+
+/** RG-4.04 : un agrement est perime si sa date de validite est < aujourd'hui. */
+function isExpired(value: string): boolean {
+    const date = new Date(value)
+    if (Number.isNaN(date.getTime())) {
+        return false
+    }
+    const today = new Date()
+    today.setHours(0, 0, 0, 0)
+    date.setHours(0, 0, 0, 0)
+    return date.getTime() < today.getTime()
+}
+
+/** Format court francais JJ-MM-AAAA (chaine vide si date absente / invalide). */
+function formatDateFr(value: string | null | undefined): string {
+    if (!value) {
+        return ''
+    }
+    const date = new Date(value)
+    if (Number.isNaN(date.getTime())) {
+        return ''
+    }
+    const day = String(date.getDate()).padStart(2, '0')
+    const month = String(date.getMonth() + 1).padStart(2, '0')
+    return `${day}-${month}-${date.getFullYear()}`
+}
+
+/** Clic sur une ligne du datatable → retrouve la ligne QUALIMAT source + modal. */
+function onQualimatRowClick(item: Record<string, unknown>): void {
+    const row = qualimatItems.value.find(r => r.id === item.id)
+    if (row) {
+        askIntegrate(row)
+    }
+}
+
+/** Ouvre la modal de confirmation d'integration pour une ligne QUALIMAT. */
+function askIntegrate(row: QualimatCarrierRow): void {
+    pendingRow.value = row
+    confirmOpen.value = true
+}
+
+/** Confirme l'integration : copie + PATCH (cf. useCarrierForm.applyQualimatSelection). */
+async function confirmIntegrate(): Promise<void> {
+    const row = pendingRow.value
+    confirmOpen.value = false
+    if (row === null) {
+        return
+    }
+    const ok = await applyQualimatSelection(row)
+    if (ok) {
+        toast.success({ title: t('transport.carriers.toast.integrateSuccess') })
+    }
+}
+
 /** Retour vers le repertoire transporteurs (fleche d'en-tete). */
 function goBack(): void {
     router.push('/carriers')
 }
 
-/** Valide le formulaire principal (POST /carriers ; bascule gerée par le composable). */
+/** Valide le formulaire principal (POST /carriers ; bascule geree par le composable). */
 async function onSubmitMain(): Promise<void> {
     await submitMain()
 }

frontend/modules/transport/types/carrierForm.ts

@@ -1,22 +1,36 @@
 /**
- * Types du workflow « Ajouter un transporteur » (M4 Transport, ERP-165).
+ * Types du workflow « Ajouter un transporteur » (M4 Transport, ERP-165 / ERP-166).
  *
- * Périmètre ERP-165 = formulaire PRINCIPAL (pré-onglets) uniquement : Nom +
+ * Périmètre :
- * Certification + Affréter. Les champs conditionnels (indexation / benne / volume
+ *  - ERP-165 : formulaire PRINCIPAL minimal (Nom + Certification + Affréter).
- * si affrété, décharge si AUTRE, immatriculations LIOT) et la saisie assistée
+ *  - ERP-166 : champs CONDITIONNELS du formulaire principal (indexation / benne /
- * QUALIMAT arrivent à ERP-166 ; les onglets Adresses / Contacts / Prix aux tickets
+ *    volume si affrété — RG-4.03 ; décharge si AUTRE — RG-4.02 ; immatriculations
- * suivants. On garde donc volontairement ce draft minimal — il s'étendra.
+ *    LIOT — RG-4.01) + saisie assistée QUALIMAT (copie name / certification /
+ *    adresse + FK qualimatCarrier — RG-4.01 / § 2.5).
+ *
+ * L'upload réel de la décharge (file → IRI via useUpload) arrive à ERP-171 ; ici
+ * on porte seulement l'IRI résolu (`dischargeDocumentIri`).
  */
 
 /**
- * Brouillon du formulaire principal. `certificationType` est un code enum back
+ * Brouillon du formulaire principal. Les décimales (indexation / volume) sont
- * (GMP_PLUS | OVOCOM | COMPTE_PROPRE | AUTRE ; QUALIMAT sera posé par la saisie
+ * portées en `string` car `MalioInputNumber` émet une chaîne ; le serveur parse.
- * assistée à ERP-166) ou `null` tant que rien n'est choisi.
+ * `certificationType` est un code enum back (GMP_PLUS | OVOCOM | COMPTE_PROPRE |
+ * AUTRE | QUALIMAT — ce dernier posé par la saisie assistée) ou `null`.
+ * `containerType` vaut `BENNE` | `FOND_MOUVANT` (radio) ou `null`.
  */
 export interface CarrierMainDraft {
     name: string
     certificationType: string | null
     isChartered: boolean
+    indexationRate: string
+    containerType: string | null
+    volumeM3: string
+    liotPlates: string
+    /** IRI du document de décharge (résolu par useUpload — ERP-171). */
+    dischargeDocumentIri: string | null
+    /** IRI de la ligne QUALIMAT liée (saisie assistée — null si non QUALIMAT). */
+    qualimatCarrierIri: string | null
 }
 
 /** Brouillon principal vide (état initial du formulaire de création). */
@@ -25,9 +39,32 @@ export function emptyCarrierMain(): CarrierMainDraft {
         name: '',
         certificationType: null,
         isChartered: false,
+        indexationRate: '',
+        containerType: null,
+        volumeM3: '',
+        liotPlates: '',
+        dischargeDocumentIri: null,
+        qualimatCarrierIri: null,
     }
 }
 
+/**
+ * Adresse copiée depuis le référentiel QUALIMAT à la sélection (RG-4.01 / § 2.5).
+ * Stockée dans l'état du formulaire pour alimenter l'onglet Adresses (ticket
+ * ultérieur) ; pré-remplie « France » côté pays par défaut.
+ */
+export interface CarrierAddressCopy {
+    country: string
+    postalCode: string
+    city: string
+    street: string
+}
+
+/** Adresse copiée vide. */
+export function emptyCarrierAddressCopy(): CarrierAddressCopy {
+    return { country: 'France', postalCode: '', city: '', street: '' }
+}
+
 /**
  * Réponse du POST / PATCH principal (groupe `carrier:read`). Le serveur renvoie
  * le nom normalisé (UPPERCASE, RG-4.13) que l'UI réaffiche tel quel.