fix: synchroniser l'irrigation par planche

Author: Guigui64260

src/app/api/calendrier/route.ts

@@ -8,6 +8,7 @@ import { NextRequest, NextResponse } from 'next/server'
 import { requireAuthApi, getUserId } from '@/lib/auth-utils'
 import prisma from '@/lib/prisma'
 import { fetchOpenMeteoForecast, fetchOpenMeteoHistory } from '@/lib/meteo'
+import { grouperIrrigationsPlanifieesParPlancheEtJour } from '@/lib/irrigation-planche'
 
 export async function GET(request: NextRequest) {
   const { error, session } = await requireAuthApi()
@@ -160,13 +161,12 @@ export async function GET(request: NextRequest) {
     const periodeExploitable = start <= horizonForecast
 
     if (periodeExploitable && irrigationsPlanifiees.length > 0) {
-      let hasDirectCoords = false
-      for (const irr of irrigationsPlanifiees) {
+      const manqueCoordonnees = irrigationsPlanifiees.some((irr) => {
         const lat = irr.culture.planche?.parcelleGeo?.centroidLat
         const lng = irr.culture.planche?.parcelleGeo?.centroidLng
-        if (lat && lng) { hasDirectCoords = true; break }
-      }
-      if (!hasDirectCoords) {
+        return !lat || !lng
+      })
+      if (manqueCoordonnees) {
         const userParcelle = await prisma.parcelleGeo.findFirst({
           where: { userId },
           select: { centroidLat: true, centroidLng: true },
@@ -269,7 +269,33 @@ export async function GET(request: NextRequest) {
       })
     }
 
-    // Formater les événements
+    const irrigationEvents = grouperIrrigationsPlanifieesParPlancheEtJour(
+      irrigationsPlanifiees.map(i => {
+        const meteo = getIrrigationMeteo(i)
+        return {
+          id: i.id,
+          type: 'irrigation' as const,
+          especeId: i.culture.especeId,
+          varieteId: i.culture.varieteId || null,
+          plancheId: i.culture.planche?.nom || null,
+          plancheName: i.culture.planche?.nom || null,
+          ilot: i.culture.planche?.ilot || null,
+          datePrevue: i.datePrevue.toISOString(),
+          date: i.datePrevue.toISOString(),
+          fait: i.fait,
+          couleur: i.culture.espece?.couleur || null,
+          especeNom: i.culture.espece?.nom ?? i.culture.especeId,
+          varieteNom: i.culture.variete?.nom ?? i.culture.varieteId ?? null,
+          cultureId: i.culture.id,
+          retardJours: 0,
+          pluiePrevue: meteo.pluiePrevue !== null ? Math.round(meteo.pluiePrevue * 10) / 10 : null,
+          probablementInutile: meteo.probablementInutile,
+        }
+      })
+    )
+
+    // Formater les événements. Les irrigations sont regroupées par planche
+    // et par jour pour éviter plusieurs alertes pour un même passage.
     const events = [
       ...culturesAvecSemis.map(c => ({
         id: c.id,
@@ -310,25 +336,7 @@ export async function GET(request: NextRequest) {
         especeNom: c.espece?.nom ?? c.especeId,
         varieteNom: c.variete?.nom ?? c.varieteId ?? null,
       })),
-      ...irrigationsPlanifiees.map(i => {
-        const meteo = getIrrigationMeteo(i)
-        return {
-          id: i.id,
-          type: 'irrigation' as const,
-          especeId: i.culture.especeId,
-          varieteId: i.culture.varieteId || null,
-          plancheName: i.culture.planche?.nom || null,
-          ilot: i.culture.planche?.ilot || null,
-          date: i.datePrevue.toISOString(),
-          fait: i.fait,
-          couleur: i.culture.espece?.couleur || null,
-          especeNom: i.culture.espece?.nom ?? i.culture.especeId,
-          varieteNom: i.culture.variete?.nom ?? i.culture.varieteId ?? null,
-          cultureId: i.culture.id,
-          pluiePrevue: meteo.pluiePrevue !== null ? Math.round(meteo.pluiePrevue * 10) / 10 : null,
-          probablementInutile: meteo.probablementInutile,
-        }
-      }),
+      ...irrigationEvents,
     ]
 
     // Trier par date
@@ -340,7 +348,7 @@ export async function GET(request: NextRequest) {
         semis: culturesAvecSemis.length,
         plantations: culturesAvecPlantation.length,
         recoltes: culturesAvecRecolte.length,
-        irrigations: irrigationsPlanifiees.length,
+        irrigations: irrigationEvents.length,
         total: events.length,
       },
     })

src/app/api/cultures/irriguer/route.ts

@@ -15,7 +15,6 @@
 import { NextRequest, NextResponse } from 'next/server'
 import { requireAuthApi, getUserId } from '@/lib/auth-utils'
 import prisma from '@/lib/prisma'
-import { irrigationCache, irrigationCacheKey } from '@/lib/irrigation-cache'
 import { fetchOpenMeteoForecast, fetchOpenMeteoHistory } from '@/lib/meteo'
 import type { MeteoJournaliere, MeteoPrevision } from '@/lib/meteo'
 import {
@@ -25,6 +24,8 @@ import {
   alerteSecheresse,
 } from '@/lib/soil-quality'
 import { cultureIrrigationDemarreeWhere } from '@/lib/irrigation-eligibility'
+import { enregistrerArrosageCultures } from '@/lib/irrigation-recording'
+import { surfaceCultureM2 } from '@/lib/culture-surface'
 
 // ── Types internes ──────────────────────────────────────────
 
@@ -510,9 +511,7 @@ export async function GET(request: NextRequest) {
       }
 
       // Surface
-      const surface = c.nbRangs && c.longueur && c.planche?.largeur
-        ? (c.nbRangs * c.longueur * c.planche.largeur)
-        : (c.planche?.surface || 0)
+      const surface = surfaceCultureM2(c)
 
       const besoinEau = c.espece?.besoinEau || 3
       const retentionEauSol = c.planche?.retentionEau || null
@@ -600,6 +599,21 @@ export async function GET(request: NextRequest) {
     }
 
     // 8. Stats
+    // Une planche multiculture est arrosée en un seul passage. Additionner
+    // les estimations de chaque culture ferait compter plusieurs fois la
+    // même surface ; le besoin le plus exigeant pilote donc la planche.
+    const consommationParPlanche = new Map<string, number>()
+    for (const culture of culturesAvecUrgence) {
+      const key = culture.plancheId ?? `culture:${culture.id}`
+      consommationParPlanche.set(
+        key,
+        Math.max(
+          consommationParPlanche.get(key) ?? 0,
+          culture.consommationEauSemaine
+        )
+      )
+    }
+
     const stats = {
       total: cultures.length,
       nbIlots: Object.keys(parIlot).length,
@@ -609,7 +623,9 @@ export async function GET(request: NextRequest) {
       jamaisArrose: culturesAvecUrgence.filter(c => c.joursSansEau === null).length,
       prochainesIrrigations7j: culturesAvecUrgence.reduce((s, c) => s + c.prochainesIrrigations, 0),
       irrigationsAutoValidees: irrigationsAutoValidees.length,
-      consommationTotaleEstimee: Math.round(culturesAvecUrgence.reduce((s, c) => s + c.consommationEauSemaine, 0)),
+      consommationTotaleEstimee: Math.round(
+        Array.from(consommationParPlanche.values()).reduce((s, litres) => s + litres, 0)
+      ),
       parTypeIrrigation: Object.entries(parTypeIrrigation).map(([type, cultures]) => ({
         type,
         count: cultures.length,
@@ -655,18 +671,18 @@ export async function PATCH(request: NextRequest) {
     const body = await request.json()
     const { cultureId, cultureIds, aIrriguer, marquerArrosage } = body
 
-    // Arrosage multiple (groupe par îlot)
+    // Arrosage multiple (groupe par îlot). Chaque culture demandée étend la
+    // mise à jour à ses colocataires actifs sur la même planche.
     if (marquerArrosage && cultureIds && Array.isArray(cultureIds)) {
-      const now = new Date()
-      await prisma.culture.updateMany({
-        where: {
-          id: { in: cultureIds },
-          userId,
-        },
-        data: { derniereIrrigation: now },
+      const result = await enregistrerArrosageCultures({
+        userId,
+        cultureIds,
+      })
+      return NextResponse.json({
+        success: true,
+        ...result,
+        date: result.dateEffective,
       })
-      irrigationCache.invalidateUser(userId)
-      return NextResponse.json({ success: true, date: now })
     }
 
     // Arrosage simple ou toggle aIrriguer
@@ -677,32 +693,39 @@ export async function PATCH(request: NextRequest) {
       )
     }
 
-    // Vérifier que la culture appartient à l'utilisateur
+    // Noter l'arrosage
+    if (marquerArrosage) {
+      const result = await enregistrerArrosageCultures({
+        userId,
+        cultureIds: [cultureId],
+      })
+      if (result.culturesMisesAJour === 0) {
+        return NextResponse.json(
+          { error: 'Culture non trouvée' },
+          { status: 404 }
+        )
+      }
+      return NextResponse.json({
+        success: true,
+        ...result,
+        date: result.dateEffective,
+      })
+    }
+
+    // Toggle aIrriguer
     const culture = await prisma.culture.findFirst({
       where: { id: cultureId, userId },
+      select: { id: true },
     })
-
     if (!culture) {
       return NextResponse.json(
         { error: 'Culture non trouvée' },
         { status: 404 }
       )
     }
 
-    // Noter l'arrosage
-    if (marquerArrosage) {
-      const now = new Date()
-      const updated = await prisma.culture.update({
-        where: { id: cultureId },
-        data: { derniereIrrigation: now },
-      })
-      irrigationCache.invalidateUser(userId)
-      return NextResponse.json({ success: true, data: updated, date: now })
-    }
-
-    // Toggle aIrriguer
     const updated = await prisma.culture.update({
-      where: { id: cultureId },
+      where: { id: culture.id },
       data: { aIrriguer },
     })
 

src/app/api/irrigations/[id]/route.ts

@@ -8,6 +8,8 @@
 import { NextRequest, NextResponse } from 'next/server'
 import prisma from '@/lib/prisma'
 import { requireAuthApi, getUserId } from '@/lib/auth-utils'
+import { enregistrerArrosageCultures } from '@/lib/irrigation-recording'
+import type { Prisma } from '@prisma/client'
 
 // GET /api/irrigations/[id]
 export async function GET(
@@ -67,6 +69,11 @@ export async function PATCH(
     // Vérifier que l'irrigation appartient à l'utilisateur
     const existing = await prisma.irrigationPlanifiee.findFirst({
       where: { id, userId },
+      include: {
+        culture: {
+          select: { plancheId: true },
+        },
+      },
     })
 
     if (!existing) {
@@ -78,7 +85,7 @@ export async function PATCH(
 
     const { fait, dateEffective, datePrevue, notes } = body
 
-    const updateData: any = {}
+    const updateData: Prisma.IrrigationPlanifieeUpdateManyMutationInput = {}
 
     if (typeof fait === 'boolean') {
       updateData.fait = fait
@@ -100,9 +107,39 @@ export async function PATCH(
       updateData.notes = notes
     }
 
-    const irrigation = await prisma.irrigationPlanifiee.update({
-      where: { id },
+    // Une ligne du calendrier représente désormais un passage par planche et
+    // par jour. Répercuter la modification sur les anciennes lignes
+    // culture-par-culture évite qu'un doublon réapparaisse après un déplacement
+    // ou une validation.
+    const debutJour = new Date(existing.datePrevue)
+    debutJour.setHours(0, 0, 0, 0)
+    const finJour = new Date(existing.datePrevue)
+    finJour.setHours(23, 59, 59, 999)
+
+    const irrigationsDuPassage = existing.culture.plancheId
+      ? await prisma.irrigationPlanifiee.findMany({
+          where: {
+            userId,
+            datePrevue: { gte: debutJour, lte: finJour },
+            culture: {
+              plancheId: existing.culture.plancheId,
+            },
+          },
+          select: { id: true },
+        })
+      : [{ id }]
+    const irrigationIds = irrigationsDuPassage.map((item) => item.id)
+
+    await prisma.irrigationPlanifiee.updateMany({
+      where: {
+        userId,
+        id: { in: irrigationIds },
+      },
       data: updateData,
+    })
+
+    const irrigation = await prisma.irrigationPlanifiee.findUniqueOrThrow({
+      where: { id },
       include: {
         culture: {
           include: {
@@ -112,7 +149,22 @@ export async function PATCH(
       },
     })
 
-    return NextResponse.json(irrigation)
+    // Cocher une irrigation planifiée signifie qu'un passage réel a eu lieu.
+    // On réconcilie donc aussi la date du dernier arrosage, les éventuelles
+    // cultures voisines sur la même planche et les tâches dues en doublon.
+    const impactArrosage = fait === true
+      ? await enregistrerArrosageCultures({
+          userId,
+          cultureIds: [existing.cultureId],
+          dateEffective: irrigation.dateEffective ?? new Date(),
+        })
+      : null
+
+    return NextResponse.json({
+      ...irrigation,
+      irrigationIds,
+      impactArrosage,
+    })
   } catch (error) {
     console.error('PATCH /api/irrigations/[id] error:', error)
     return NextResponse.json(

src/app/api/meteo/irrigation/route.ts

@@ -14,6 +14,7 @@ import { fetchEcowittData, fetchOpenMeteoForecast, fetchOpenMeteoHistory, fetchW
 import { adapterConseilSousAbri, genererRecommandationIrrigation } from '@/lib/meteo-agro'
 import { irrigationCache, irrigationCacheKey } from '@/lib/irrigation-cache'
 import { cultureIrrigationDemarreeWhere } from '@/lib/irrigation-eligibility'
+import { grouperRecommandationsParPlanche } from '@/lib/irrigation-planche'
 import type { MeteoJournaliere, MeteoPrevision } from '@/lib/meteo'
 import type { Prisma } from '@prisma/client'
 
@@ -78,6 +79,7 @@ export async function GET(request: NextRequest) {
         variete: { select: { nom: true } },
         planche: {
           select: {
+            id: true,
             nom: true,
             type: true,
             irrigation: true,
@@ -133,7 +135,7 @@ export async function GET(request: NextRequest) {
       parCoords.get(key)!.cultures.push(culture)
     }
 
-    const recommandations = []
+    const recommandationsCultures = []
 
     for (const [, group] of parCoords) {
       let historique7j: MeteoJournaliere[]
@@ -203,8 +205,9 @@ export async function GET(request: NextRequest) {
           reco.joursSansPluie = 0
         }
 
-        recommandations.push({
+        recommandationsCultures.push({
           ...reco,
+          plancheId: culture.planche!.id,
           varietyName: culture.variete?.nom ?? null,
           etatCulture: culture.plantationFaite ? 'Plantée' : 'Semée',
           derniereIrrigation: culture.derniereIrrigation?.toISOString() ?? null,
@@ -213,6 +216,11 @@ export async function GET(request: NextRequest) {
       }
     }
 
+    // Une action d'arrosage concerne la planche entière. Sur une planche
+    // multiculture, une seule alerte est affichée et le besoin le plus
+    // exigeant pilote la recommandation.
+    const recommandations = grouperRecommandationsParPlanche(recommandationsCultures)
+
     // Trier par urgence
     const ordreUrgence = { critique: 0, haute: 1, moyenne: 2, faible: 3, aucune: 4 }
     recommandations.sort((a, b) =>
@@ -222,6 +230,7 @@ export async function GET(request: NextRequest) {
     const result = {
       recommandations,
       total: recommandations.length,
+      totalCultures: recommandationsCultures.length,
       urgentes: recommandations.filter(r => r.urgence === 'critique' || r.urgence === 'haute').length,
     }