fix : validation bulk des heures. Moins de lag et de bug

frontend/composables/useHoursPage.ts

@@ -12,6 +12,8 @@ import { listAbsenceTypes } from '~/services/absence-types'
 import { createAbsence, deleteAbsence, listAbsences, updateAbsence } from '~/services/absences'
 import { listPublicHolidays } from '~/services/public-holidays'
 import {
+  bulkUpdateWorkHourSiteValidation,
+  bulkUpdateWorkHourValidation,
   bulkUpsertWorkHours,
   getWorkHourDayContext,
   getWeeklyWorkHourSummary,
@@ -136,25 +138,61 @@ export const useHoursPage = () => {
     return true
   }
 
-  const validatableEmployeeIds = computed(() => {
-    return employees.value
+  const canCreateValidationRowFromAbsence = (employeeId: number) => {
+    const row = rows.value[employeeId]
+    if (row?.workHourId) return false
+    const dayRow = dayContextByEmployeeId.value.get(employeeId)
+    return !!dayRow?.absenceLabel && hasContractAtSelectedDate(employeeId)
+  }
+
+  const canCreateSiteValidationRowFromAbsence = (employeeId: number) => {
+    const row = rows.value[employeeId]
+    if (row?.workHourId) return false
+    const dayRow = dayContextByEmployeeId.value.get(employeeId)
+    return !!dayRow?.absenceLabel && hasContractAtSelectedDate(employeeId)
+  }
+
+  const bulkValidatableEmployeeIds = computed(() => {
+    return visibleEmployees.value
       .map((employee) => employee.id)
-      .filter((employeeId) => canToggleValidation(employeeId))
+      .filter((employeeId) => canToggleValidation(employeeId) || canCreateValidationRowFromAbsence(employeeId))
   })
 
   const isBulkValidationChecked = computed(() => {
-    const ids = validatableEmployeeIds.value
+    const ids = bulkValidatableEmployeeIds.value
     if (ids.length === 0) return false
     return ids.every((employeeId) => rows.value[employeeId]?.isValid ?? false)
   })
 
   const isBulkValidationIndeterminate = computed(() => {
-    const ids = validatableEmployeeIds.value
+    const ids = bulkValidatableEmployeeIds.value
     if (ids.length === 0) return false
     const checkedCount = ids.filter((employeeId) => rows.value[employeeId]?.isValid ?? false).length
     return checkedCount > 0 && checkedCount < ids.length
   })
 
+  const bulkSiteValidatableEmployeeIds = computed(() => {
+    if (!isSiteManager.value) return []
+    return visibleEmployees.value
+      .map((employee) => employee.id)
+      .filter((employeeId) => canToggleSiteValidation(employeeId) || canCreateSiteValidationRowFromAbsence(employeeId))
+  })
+
+  const isBulkSiteValidationChecked = computed(() => {
+    const ids = bulkSiteValidatableEmployeeIds.value
+    if (ids.length === 0) return false
+    return ids.every((employeeId) => rows.value[employeeId]?.isSiteValid ?? false)
+  })
+
+  const isBulkSiteValidationIndeterminate = computed(() => {
+    const ids = bulkSiteValidatableEmployeeIds.value
+    if (ids.length === 0) return false
+    const checkedCount = ids.filter((employeeId) => rows.value[employeeId]?.isSiteValid ?? false).length
+    return checkedCount > 0 && checkedCount < ids.length
+  })
+
+  const canBulkToggleSiteValidation = computed(() => bulkSiteValidatableEmployeeIds.value.length > 0)
+
   const dayContextByEmployeeId = computed(() => {
     const map = new Map<number, WorkHourDayContext['rows'][number]>()
     for (const row of dayContext.value?.rows ?? []) {
@@ -748,44 +786,169 @@ export const useHoursPage = () => {
   }
 
   const toggleValidationBulk = async (checked: boolean) => {
-    const employeeIds = validatableEmployeeIds.value
+    const employeeIds = bulkValidatableEmployeeIds.value
     if (employeeIds.length === 0) return
 
-    let successCount = 0
-    let failedCount = 0
+    const pendingIds = new Set(validatingRowIds.value)
+    const availableEmployeeIds = employeeIds.filter((employeeId) => !pendingIds.has(employeeId))
+    if (availableEmployeeIds.length === 0) return
 
-    for (const employeeId of employeeIds) {
-      if (isValidationPending(employeeId)) continue
-      try {
-        await toggleValidation(employeeId, checked, { toast: false })
-        successCount += 1
-      } catch {
-        failedCount += 1
+    if (checked) {
+      const toCreateIds = availableEmployeeIds.filter((employeeId) => canCreateValidationRowFromAbsence(employeeId))
+      if (toCreateIds.length > 0) {
+        await bulkUpsertWorkHours({
+          workDate: selectedDate.value,
+          entries: toCreateIds.map((employeeId) => ({
+            employeeId,
+            morningFrom: null,
+            morningTo: null,
+            afternoonFrom: null,
+            afternoonTo: null,
+            eveningFrom: null,
+            eveningTo: null,
+            isPresentMorning: false,
+            isPresentAfternoon: false
+          }))
+        }, { toast: false })
+
+        await loadWorkHours()
       }
     }
 
-    if (failedCount === 0) {
-      toast.success({
-        title: 'Succès',
-        message: checked
-          ? `${successCount} ligne(s) validée(s).`
-          : `${successCount} validation(s) retirée(s).`
+    const targetEmployeeIds = availableEmployeeIds.filter((employeeId) => canToggleValidation(employeeId))
+    if (targetEmployeeIds.length === 0) {
+      toast.error({
+        title: 'Validation impossible',
+        message: 'Aucune ligne ne peut être validée.'
       })
       return
     }
 
-    if (successCount === 0) {
+    validatingRowIds.value = Array.from(new Set([...validatingRowIds.value, ...targetEmployeeIds]))
+
+    try {
+      const result = await bulkUpdateWorkHourValidation({
+        workDate: selectedDate.value,
+        isValid: checked,
+        employeeIds: targetEmployeeIds
+      }, { toast: false })
+
+      await loadWorkHours()
+
+      if (result.updated === 0) {
+        toast.error({
+          title: 'Erreur',
+          message: 'Aucune ligne mise à jour.'
+        })
+        return
+      }
+
+      if (result.skipped > 0) {
+        toast.success({
+          title: 'Succès partiel',
+          message: `${result.updated} mise(s) à jour, ${result.skipped} ignorée(s).`
+        })
+        return
+      }
+
+      toast.success({
+        title: 'Succès',
+        message: checked
+          ? `${result.updated} ligne(s) validée(s).`
+          : `${result.updated} validation(s) retirée(s).`
+      })
+    } catch {
       toast.error({
         title: 'Erreur',
         message: 'Impossible de mettre à jour les validations.'
       })
+    } finally {
+      validatingRowIds.value = validatingRowIds.value.filter((id) => !targetEmployeeIds.includes(id))
+    }
+  }
+
+  const toggleSiteValidationBulk = async (checked: boolean) => {
+    if (!isSiteManager.value) return
+
+    const employeeIds = bulkSiteValidatableEmployeeIds.value
+    if (employeeIds.length === 0) return
+
+    const pendingIds = new Set(siteValidatingRowIds.value)
+    const availableEmployeeIds = employeeIds.filter((employeeId) => !pendingIds.has(employeeId))
+    if (availableEmployeeIds.length === 0) return
+
+    if (checked) {
+      const toCreateIds = availableEmployeeIds.filter((employeeId) => canCreateSiteValidationRowFromAbsence(employeeId))
+      if (toCreateIds.length > 0) {
+        await bulkUpsertWorkHours({
+          workDate: selectedDate.value,
+          entries: toCreateIds.map((employeeId) => ({
+            employeeId,
+            morningFrom: null,
+            morningTo: null,
+            afternoonFrom: null,
+            afternoonTo: null,
+            eveningFrom: null,
+            eveningTo: null,
+            isPresentMorning: false,
+            isPresentAfternoon: false
+          }))
+        }, { toast: false })
+
+        await loadWorkHours()
+      }
+    }
+
+    const targetEmployeeIds = availableEmployeeIds.filter((employeeId) => canToggleSiteValidation(employeeId))
+    if (targetEmployeeIds.length === 0) {
+      toast.error({
+        title: 'Validation impossible',
+        message: 'Aucune ligne ne peut être validée côté site.'
+      })
       return
     }
 
-    toast.error({
-      title: 'Erreur',
-      message: `${successCount} mise(s) à jour, ${failedCount} en échec.`
-    })
+    siteValidatingRowIds.value = Array.from(new Set([...siteValidatingRowIds.value, ...targetEmployeeIds]))
+
+    try {
+      const result = await bulkUpdateWorkHourSiteValidation({
+        workDate: selectedDate.value,
+        isSiteValid: checked,
+        employeeIds: targetEmployeeIds
+      }, { toast: false })
+
+      await loadWorkHours()
+
+      if (result.updated === 0) {
+        toast.error({
+          title: 'Erreur',
+          message: 'Aucune ligne site mise à jour.'
+        })
+        return
+      }
+
+      if (result.skipped > 0) {
+        toast.success({
+          title: 'Succès partiel',
+          message: `${result.updated} mise(s) à jour, ${result.skipped} ignorée(s).`
+        })
+        return
+      }
+
+      toast.success({
+        title: 'Succès',
+        message: checked
+          ? `${result.updated} validation(s) site enregistrée(s).`
+          : `${result.updated} validation(s) site retirée(s).`
+      })
+    } catch {
+      toast.error({
+        title: 'Erreur',
+        message: 'Impossible de mettre à jour les validations site.'
+      })
+    } finally {
+      siteValidatingRowIds.value = siteValidatingRowIds.value.filter((id) => !targetEmployeeIds.includes(id))
+    }
   }
 
   const loadEmployees = async () => {
@@ -965,12 +1128,15 @@ export const useHoursPage = () => {
     isSiteValidationPending,
     canToggleValidation,
     canToggleSiteValidation,
-    validatableEmployeeIds,
     isBulkValidationChecked,
     isBulkValidationIndeterminate,
+    isBulkSiteValidationChecked,
+    isBulkSiteValidationIndeterminate,
+    canBulkToggleSiteValidation,
     toggleValidation,
     toggleSiteValidation,
     toggleValidationBulk,
+    toggleSiteValidationBulk,
     getRowMetrics,
     getRowAbsenceLabel,
     getRowAbsenceStyle,