temp

backend/time_tracking/migrations/0003_timeentry_group_id.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.2.17 on 2026-09-20 01:45
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('time_tracking', '0002_fix_user_foreign_key'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='timeentry',
+            name='group_id',
+            field=models.UUIDField(blank=True, db_index=True, null=True),
+        ),
+    ]

backend/time_tracking/models.py

@@ -1,6 +1,8 @@
+import uuid
+from datetime import datetime
+
 from django.conf import settings
 from django.db import models
-from datetime import datetime
 
 
 class TimeEntry(models.Model):
@@ -10,29 +12,92 @@ class TimeEntry(models.Model):
         related_name='time_entries',
     )
 
+    # Même group_id = même pointage logique réparti sur plusieurs jours.
+    # NULL pour les pointages classiques sur une seule journée.
+    group_id = models.UUIDField(
+        null=True,
+        blank=True,
+        db_index=True,
+    )
+
     date = models.DateField()
-    start_time = models.TimeField(null=True, blank=True)
+
-    end_time = models.TimeField(null=True, blank=True)
+    start_time = models.TimeField(
-    created_at = models.DateTimeField(auto_now_add=True)
+        null=True,
-    updated_at = models.DateTimeField(auto_now=True)
+        blank=True,
+    )
+
+    end_time = models.TimeField(
+        null=True,
+        blank=True,
+    )
+
+    end_time = models.TimeField(
+        null=True,
+        blank=True,
+    )
+
+    created_at = models.DateTimeField(
+        auto_now_add=True,
+    )
+
+    updated_at = models.DateTimeField(
+        auto_now=True,
+    )
 
     class Meta:
         ordering = ['-date', '-start_time']
-        unique_together = ['user', 'date', 'start_time']
+
+        unique_together = [
+            'user',
+            'date',
+            'start_time',
+        ]
 
     def __str__(self):
-        return f"{self.user.username} - {self.date} ({self.start_time} to {self.end_time})"
+        return (
+            f"{self.user.username} - "
+            f"{self.date} "
+            f"({self.start_time} to {self.end_time})"
+        )
 
     @property
     def duration(self):
-        """Calculate duration in hours"""
+        if not self.start_time or not self.end_time:
-        if self.start_time and self.end_time:
+            return None
-            start = datetime.combine(self.date, self.start_time)
+
-            end = datetime.combine(self.date, self.end_time)
+        end_date = self.end_date or self.date
-            return (end - start).total_seconds() / 3600
+
-        return None
+        start = datetime.combine(
+            self.date,
+            self.start_time,
+        )
+
+        end = datetime.combine(
+            end_date,
+            self.end_time,
+        )
+
+        seconds = (
+            end - start
+        ).total_seconds()
+
+        if seconds < 0:
+            return None
+
+        return seconds / 3600
 
     @property
     def day_of_week(self):
-        """Get day of week as string"""
         return self.date.strftime('%A')
+
+    @property
+    def is_complete(self):
+        return bool(
+            self.start_time
+            and self.end_time
+        )
+
+    @property
+    def is_incomplete(self):
+        return not self.is_complete

backend/time_tracking/serializers.py

@@ -1,5 +1,9 @@
-from rest_framework import serializers
+from datetime import time as datetime_time
+from uuid import uuid4
+
 from django.contrib.auth import get_user_model
+from django.db import transaction
+from rest_framework import serializers
 
 from .models import TimeEntry
 
@@ -10,17 +14,27 @@ User = get_user_model()
 class UserSerializer(serializers.ModelSerializer):
     class Meta:
         model = User
-        fields = ['id', 'username', 'first_name', 'last_name']
+        fields = [
+            'id',
+            'username',
+            'first_name',
+            'last_name',
+        ]
 
 
 class TimeEntrySerializer(serializers.ModelSerializer):
     user = UserSerializer(read_only=True)
 
+    is_complete = serializers.ReadOnlyField()
+    is_incomplete = serializers.ReadOnlyField()
+
     class Meta:
         model = TimeEntry
+
         fields = [
             'id',
             'user',
+            'group_id',
             'date',
             'start_time',
             'end_time',
@@ -28,7 +42,10 @@ class TimeEntrySerializer(serializers.ModelSerializer):
             'updated_at',
             'duration',
             'day_of_week',
+            'is_complete',
+            'is_incomplete',
         ]
+
         read_only_fields = [
             'id',
             'user',
@@ -36,6 +53,8 @@ class TimeEntrySerializer(serializers.ModelSerializer):
             'updated_at',
             'duration',
             'day_of_week',
+            'is_complete',
+            'is_incomplete',
         ]
 
     def create(self, validated_data):
@@ -55,46 +74,171 @@ class TimeEntryCreateSerializer(serializers.ModelSerializer):
         required=False,
     )
 
+    end_date = serializers.DateField(
+        write_only=True,
+        required=False,
+    )
+
     class Meta:
         model = TimeEntry
-        fields = ['user_id', 'date', 'start_time', 'end_time']
+
+        fields = [
+            'user_id',
+            'date',
+            'end_date',
+            'start_time',
+            'end_time',
+        ]
 
     def validate(self, attrs):
-        if not attrs.get('start_time') and not attrs.get('end_time'):
+        start_time = attrs.get('start_time')
+        end_time = attrs.get('end_time')
+        date = attrs.get('date')
+        end_date = attrs.get('end_date') or date
+
+        if not start_time and not end_time:
             raise serializers.ValidationError(
                 'Une heure d’entrée ou de sortie est requise.'
             )
 
+        if end_date < date:
+            raise serializers.ValidationError(
+                'La date de sortie doit être postérieure ou égale à la date d’entrée.'
+            )
+
+        # Une entrée et une sortie le même jour doivent être cohérentes.
         if (
-            attrs.get('start_time')
+            date == end_date
-            and attrs.get('end_time')
+            and start_time
-            and attrs['end_time'] <= attrs['start_time']
+            and end_time
+            and end_time <= start_time
         ):
             raise serializers.ValidationError(
                 'L’heure de sortie doit être après l’entrée.'
             )
 
+        # Pour un pointage sur plusieurs jours, les deux extrémités
+        # doivent être connues.
+        if (
+            date != end_date
+            and (
+                not start_time
+                or not end_time
+            )
+        ):
+            raise serializers.ValidationError(
+                'Un pointage sur plusieurs jours nécessite une heure d’entrée et une heure de sortie.'
+            )
+
+        attrs['end_date'] = end_date
+
         return attrs
 
+    def create(self, validated_data):
+        user = validated_data.pop('user', None)
+        end_date = validated_data.pop('end_date')
+
+        if user is None:
+            user = self.context['request'].user
+
+        start_date = validated_data['date']
+        start_time = validated_data.get('start_time')
+        end_time = validated_data.get('end_time')
+
+        # Pointage classique sur une seule journée.
+        if start_date == end_date:
+            return TimeEntry.objects.create(
+                user=user,
+                date=start_date,
+                start_time=start_time,
+                end_time=end_time,
+            )
+
+        # Pointage multi-jours :
+        #
+        # Exemple :
+        # 20/09 14:00 -> 22/09 10:00
+        #
+        # 20/09 14:00 -> 23:59:59
+        # 21/09 00:00 -> 23:59:59
+        # 22/09 00:00 -> 10:00
+        group_id = uuid4()
+
+        created_entries = []
+
+        current_date = start_date
+
+        with transaction.atomic():
+            while current_date <= end_date:
+                if current_date == start_date:
+                    entry_start = start_time
+                    entry_end = datetime_time(
+                        23,
+                        59,
+                        59,
+                    )
+
+                elif current_date == end_date:
+                    entry_start = datetime_time.min
+                    entry_end = end_time
+
+                else:
+                    entry_start = datetime_time.min
+                    entry_end = datetime_time(
+                        23,
+                        59,
+                        59,
+                    )
+
+                created_entries.append(
+                    TimeEntry.objects.create(
+                        user=user,
+                        group_id=group_id,
+                        date=current_date,
+                        start_time=entry_start,
+                        end_time=entry_end,
+                    )
+                )
+
+                from datetime import timedelta
+
+                current_date += timedelta(days=1)
+
+        return created_entries[0]
+
 
 class TimeEntryUpdateSerializer(serializers.ModelSerializer):
     class Meta:
         model = TimeEntry
-        fields = ['start_time', 'end_time']
+
+        fields = [
+            'start_time',
+            'end_time',
+        ]
 
     def validate(self, attrs):
-        if not attrs.get('start_time') and not attrs.get('end_time'):
+        start_time = attrs.get(
+            'start_time',
+            self.instance.start_time,
+        )
+
+        end_time = attrs.get(
+            'end_time',
+            self.instance.end_time,
+        )
+
+        if not start_time and not end_time:
             raise serializers.ValidationError(
                 'Une heure d’entrée ou de sortie est requise.'
             )
 
         if (
-            attrs.get('start_time')
+            start_time
-            and attrs.get('end_time')
+            and end_time
-            and attrs['end_time'] <= attrs['start_time']
+            and end_time <= start_time
         ):
             raise serializers.ValidationError(
-                'L’heure de sortie doit être après l’heure d’entrée.'
+                'L’heure de sortie doit être après l’entrée.'
             )
 
         return attrs
@@ -104,4 +248,6 @@ class WeeklySummarySerializer(serializers.Serializer):
     user = serializers.CharField()
     username = serializers.CharField()
     total_hours = serializers.FloatField()
-    entries = serializers.ListField(child=serializers.DictField())
+    entries = serializers.ListField(
+        child=serializers.DictField(),
+    )

backend/time_tracking/views.py

@@ -1,38 +1,49 @@
-from rest_framework import generics, status
-from rest_framework.response import Response
-from rest_framework.permissions import IsAuthenticated
-from rest_framework.views import APIView
-from django.conf import settings
-from django.db import transaction
-from django.utils import timezone
 from datetime import timedelta
 from datetime import time as datetime_time
+
 from decouple import config
+from django.conf import settings
+from django.contrib.auth import get_user_model
+from django.db import transaction
+from django.utils import timezone
+from rest_framework import generics, status
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
 from .models import TimeEntry
 from .serializers import (
-    TimeEntrySerializer, 
     TimeEntryCreateSerializer,
+    TimeEntrySerializer,
     TimeEntryUpdateSerializer,
-    WeeklySummarySerializer
+    WeeklySummarySerializer,
 )
 
+
+User = get_user_model()
+
+
 class TimeEntryListView(generics.ListAPIView):
     serializer_class = TimeEntrySerializer
     permission_classes = [IsAuthenticated]
 
     def get_queryset(self):
         user = self.request.user
-        # Staff members can view all entries, regular users only their own
+
         if user.is_staff or user.is_superuser:
             return TimeEntry.objects.all()
-        return TimeEntry.objects.filter(user=user)
+
+        return TimeEntry.objects.filter(
+            user=user,
+        )
+
 
 class TimeEntryCreateView(generics.CreateAPIView):
     serializer_class = TimeEntryCreateSerializer
     permission_classes = [IsAuthenticated]
 
     def perform_create(self, serializer):
-        requested_user = serializer.validated_data.pop('user', None)
+        requested_user = serializer.validated_data.get('user')
 
         if requested_user is not None:
             if not (
@@ -45,21 +56,36 @@ class TimeEntryCreateView(generics.CreateAPIView):
                     "Vous ne pouvez pas créer un pointage pour un autre utilisateur."
                 )
 
-            self.created_entry = serializer.save(user=requested_user)
+            self.created_entry = serializer.save(
+                user=requested_user,
+            )
+
         else:
-            self.created_entry = serializer.save(user=self.request.user)
+            self.created_entry = serializer.save(
+                user=self.request.user,
+            )
 
     def create(self, request, *args, **kwargs):
-        serializer = self.get_serializer(data=request.data)
+        serializer = self.get_serializer(
-        serializer.is_valid(raise_exception=True)
+            data=request.data,
+        )
+
+        serializer.is_valid(
+            raise_exception=True,
+        )
+
         self.perform_create(serializer)
 
         output_serializer = TimeEntrySerializer(
             self.created_entry,
-            context={'request': request},
+            context={
+                'request': request,
+            },
         )
 
-        headers = self.get_success_headers(serializer.data)
+        headers = self.get_success_headers(
+            serializer.data,
+        )
 
         return Response(
             output_serializer.data,
@@ -67,180 +93,690 @@ class TimeEntryCreateView(generics.CreateAPIView):
             headers=headers,
         )
 
+
 class TimeEntryScanView(APIView):
     permission_classes = [IsAuthenticated]
 
-    def post(self, request):
+    def _parse_code(self, raw_code):
-        code = str(request.data.get('code') or '').strip().strip('"\'')
+        code = str(
+            raw_code or ''
+        ).strip().strip('"\'"')
+
         if '=' in code:
-            code = code.split('=', 1)[1].strip().strip('"\'')
+            code = (
-        enter_code = config('SECRET_POINTAGE_ENTER', default='').strip().strip('"\'')
+                code
-        exit_code = config('SECRET_POINTAGE_EXIT', default='').strip().strip('"\'')
+                .split('=', 1)[1]
+                .strip()
+                .strip('"\'"')
+            )
+
+        return code
+
+    def _parse_time(self, value):
+        if not value:
+            now = timezone.localtime()
+
+            return now.time().replace(
+                second=0,
+                microsecond=0,
+            )
+
+        try:
+            return datetime_time.fromisoformat(
+                str(value)[:5],
+            )
+        except ValueError:
+            return None
+
+    def _serialize_entry(self, entry, request):
+        return TimeEntrySerializer(
+            entry,
+            context={
+                'request': request,
+            },
+        ).data
+
+    def post(self, request):
+        code = self._parse_code(
+            request.data.get('code'),
+        )
+
+        enter_code = config(
+            'SECRET_POINTAGE_ENTER',
+            default='',
+        ).strip().strip('"\'"')
+
+        exit_code = config(
+            'SECRET_POINTAGE_EXIT',
+            default='',
+        ).strip().strip('"\'"')
+
         if code == enter_code:
             action = 'enter'
+
         elif code == exit_code:
             action = 'exit'
+
         else:
-            return Response({'error': 'QR code de pointage invalide.'}, status=status.HTTP_400_BAD_REQUEST)
+            return Response(
+                {
+                    'error': 'QR code de pointage invalide.'
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        selected_time = self._parse_time(
+            request.data.get('time'),
+        )
+
+        if selected_time is None:
+            return Response(
+                {
+                    'error': 'Heure invalide.'
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        resolution = request.data.get(
+            'resolution',
+        )
+
+        # Heure réelle du scan.
+        #
+        # Lors d'une résolution d'un conflit "sortie sans entrée",
+        # on utilise scan_time comme heure de sortie et "time"
+        # comme heure d'entrée.
+        scan_time_value = request.data.get(
+            'scan_time',
+        )
+
+        scan_time = self._parse_time(
+            scan_time_value,
+        )
+
+        if scan_time is None:
+            scan_time = selected_time
 
         now = timezone.localtime()
-        requested_time = request.data.get('time')
+        today = now.date()
-        if requested_time:
-            try:
-                selected_time = datetime_time.fromisoformat(str(requested_time)[:5])
-            except ValueError:
-                return Response({'error': 'Heure invalide.'}, status=status.HTTP_400_BAD_REQUEST)
-        else:
-            selected_time = now.time().replace(second=0, microsecond=0)
-        resolution = request.data.get('resolution')
 
         with transaction.atomic():
-            open_entry = TimeEntry.objects.select_for_update().filter(
+
-                user=request.user,
+            # =====================================================
-                date=now.date(),
+            # RÉSOLUTION : entrée déjà ouverte
-                start_time__isnull=False,
+            # =====================================================
-                end_time__isnull=True,
+
-            ).order_by('-start_time').first()
+            if resolution == 'complete_exit':
-            open_exit = TimeEntry.objects.select_for_update().filter(
+                open_entry = (
-                user=request.user,
+                    TimeEntry.objects
-                date=now.date(),
+                    .select_for_update()
-                start_time__isnull=True,
+                    .filter(
-                end_time__isnull=False,
+                        user=request.user,
-            ).order_by('-end_time').first()
+                        start_time__isnull=False,
+                        end_time__isnull=True,
+                    )
+                    .order_by(
+                        '-date',
+                        '-start_time',
+                    )
+                    .first()
+                )
+
+                if not open_entry:
+                    return Response(
+                        {
+                            'error': 'Aucune entrée ouverte à compléter.'
+                        },
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+
+                if selected_time <= open_entry.start_time:
+                    return Response(
+                        {
+                            'error': 'L’heure de sortie doit être après l’entrée.'
+                        },
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+
+                open_entry.end_time = selected_time
+
+                open_entry.save(
+                    update_fields=[
+                        'end_time',
+                        'updated_at',
+                    ],
+                )
+
+                return Response(
+                    {
+                        'action': 'exit',
+                        'message': 'Sortie enregistrée.',
+                        'entry': self._serialize_entry(
+                            open_entry,
+                            request,
+                        ),
+                    }
+                )
+
+            # =====================================================
+            # RÉSOLUTION : sortie scannée sans entrée
+            # =====================================================
+
+            if resolution == 'complete_missing_entry':
+                missing_entry_time = selected_time
+                exit_time = scan_time
+
+                if missing_entry_time >= exit_time:
+                    return Response(
+                        {
+                            'error': "L'heure d'entrée doit être avant l'heure de sortie."
+                        },
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+
+                entry = TimeEntry.objects.create(
+                    user=request.user,
+                    date=today,
+                    start_time=missing_entry_time,
+                    end_time=exit_time,
+                )
+
+                return Response(
+                    {
+                        'action': 'exit',
+                        'message': 'Entrée et sortie enregistrées.',
+                        'entry': self._serialize_entry(
+                            entry,
+                            request,
+                        ),
+                    }
+                )
+
+            # =====================================================
+            # RÉSOLUTION : sortie existante sans entrée
+            # =====================================================
+
+            if resolution == 'complete_open_exit':
+                open_exit = (
+                    TimeEntry.objects
+                    .select_for_update()
+                    .filter(
+                        user=request.user,
+                        start_time__isnull=True,
+                        end_time__isnull=False,
+                    )
+                    .order_by(
+                        '-date',
+                        '-end_time',
+                    )
+                    .first()
+                )
+
+                if not open_exit:
+                    return Response(
+                        {
+                            'error': 'Aucune sortie incomplète à compléter.'
+                        },
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+
+                if selected_time >= open_exit.end_time:
+                    return Response(
+                        {
+                            'error': "L'heure d'entrée doit être avant la sortie."
+                        },
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+
+                open_exit.start_time = selected_time
+
+                open_exit.save(
+                    update_fields=[
+                        'start_time',
+                        'updated_at',
+                    ],
+                )
+
+                return Response(
+                    {
+                        'action': 'enter',
+                        'message': 'Entrée enregistrée.',
+                        'entry': self._serialize_entry(
+                            open_exit,
+                            request,
+                        ),
+                    }
+                )
+
+            # =====================================================
+            # POINTAGE EXISTANT DU JOUR
+            # =====================================================
+
+            open_entry = (
+                TimeEntry.objects
+                .select_for_update()
+                .filter(
+                    user=request.user,
+                    date=today,
+                    start_time__isnull=False,
+                    end_time__isnull=True,
+                )
+                .order_by(
+                    '-start_time',
+                )
+                .first()
+            )
+
+            open_exit = (
+                TimeEntry.objects
+                .select_for_update()
+                .filter(
+                    user=request.user,
+                    date=today,
+                    start_time__isnull=True,
+                    end_time__isnull=False,
+                )
+                .order_by(
+                    '-end_time',
+                )
+                .first()
+            )
+
+            # =====================================================
+            # QR ENTRÉE
+            # =====================================================
 
             if action == 'enter':
+
+                # Une entrée est déjà ouverte.
+                #
+                # IMPORTANT :
+                # on ne supprime plus l'entrée si l'utilisateur
+                # refuse. Le frontend demande d'abord confirmation.
                 if open_entry:
-                    if resolution == 'cancel_entry':
+                    return Response(
-                        open_entry.delete()
+                        {
-                        return Response({'action': action, 'message': 'Entrée annulée.'})
+                            'error': (
-                    if resolution == 'complete_entry':
+                                'Une entrée est déjà ouverte. '
-                        if selected_time <= open_entry.start_time:
+                                'Voulez-vous enregistrer une sortie ?'
-                            return Response({'error': 'L’heure de sortie doit être après l’entrée.'}, status=status.HTTP_400_BAD_REQUEST)
+                            ),
-                        open_entry.end_time = selected_time
+                            'conflict': 'open_entry',
-                        open_entry.save(update_fields=['end_time', 'updated_at'])
+                            'resolution': 'complete_exit',
-                        return Response({'action': action, 'message': 'Sortie enregistrée pour l’entrée précédente.', 'entry': TimeEntrySerializer(open_entry).data})
+                            'missing_time': 'end_time',
-                    return Response({'error': 'Une entrée est déjà ouverte.', 'conflict': 'open_entry', 'options': ['cancel_entry', 'complete_entry']}, status=status.HTTP_409_CONFLICT)
+                            'message': (
+                                'Une entrée est déjà ouverte. '
+                                'Voulez-vous enregistrer une sortie ?'
+                            ),
+                            'scan_time': selected_time.strftime(
+                                '%H:%M'
+                            ),
+                        },
+                        status=status.HTTP_409_CONFLICT,
+                    )
+
+                # Une sortie existe sans entrée.
                 if open_exit:
-                    if resolution == 'cancel_exit':
+                    return Response(
-                        open_exit.delete()
+                        {
-                        return Response({'action': action, 'message': 'Sortie annulée.'})
+                            'error': (
-                    if resolution == 'complete_exit':
+                                'Une sortie existe déjà sans entrée.'
-                        open_exit.start_time = selected_time
+                            ),
-                        open_exit.save(update_fields=['start_time', 'updated_at'])
+                            'conflict': 'open_exit',
-                        return Response({'action': action, 'message': 'Entrée enregistrée pour la sortie précédente.', 'entry': TimeEntrySerializer(open_exit).data})
+                            'resolution': 'complete_open_exit',
-                    return Response({'error': 'Une sortie existe déjà.', 'conflict': 'open_exit', 'options': ['cancel_exit', 'complete_exit']}, status=status.HTTP_409_CONFLICT)
+                            'missing_time': 'start_time',
-                entry = TimeEntry.objects.create(user=request.user, date=now.date(), start_time=selected_time)
+                            'message': (
-                message = 'Entrée enregistrée.'
+                                'Une sortie existe déjà sans entrée. '
-            elif open_entry:
+                                'Voulez-vous renseigner l’heure d’entrée ?'
+                            ),
+                        },
+                        status=status.HTTP_409_CONFLICT,
+                    )
+
+                entry = TimeEntry.objects.create(
+                    user=request.user,
+                    date=today,
+                    start_time=selected_time,
+                )
+
+                return Response(
+                    {
+                        'action': 'enter',
+                        'message': 'Entrée enregistrée.',
+                        'entry': self._serialize_entry(
+                            entry,
+                            request,
+                        ),
+                    }
+                )
+
+            # =====================================================
+            # QR SORTIE
+            # =====================================================
+
+            # Entrée ouverte aujourd'hui :
+            # sortie normale.
+            if open_entry:
+                if selected_time <= open_entry.start_time:
+                    return Response(
+                        {
+                            'error': (
+                                "L'heure de sortie doit être "
+                                "après l'entrée."
+                            )
+                        },
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+
                 open_entry.end_time = selected_time
-                open_entry.save(update_fields=['end_time', 'updated_at'])
+
-                entry = open_entry
+                open_entry.save(
-                message = 'Sortie enregistrée.'
+                    update_fields=[
-            elif open_exit:
+                        'end_time',
-                if resolution == 'cancel_exit':
+                        'updated_at',
-                    open_exit.delete()
+                    ],
-                    return Response({'action': action, 'message': 'Sortie annulée.'})
+                )
-                if resolution == 'complete_exit':
+
-                    if selected_time >= open_exit.end_time:
+                return Response(
-                        return Response({'error': 'L’heure d’entrée doit être avant la sortie.'}, status=status.HTTP_400_BAD_REQUEST)
+                    {
-                    open_exit.start_time = selected_time
+                        'action': 'exit',
-                    open_exit.save(update_fields=['start_time', 'updated_at'])
+                        'message': 'Sortie enregistrée.',
-                    return Response({'action': action, 'message': 'Entrée enregistrée pour la sortie précédente.', 'entry': TimeEntrySerializer(open_exit).data})
+                        'entry': self._serialize_entry(
-                return Response({'error': 'Une sortie existe déjà.', 'conflict': 'open_exit', 'options': ['cancel_exit', 'complete_exit']}, status=status.HTTP_409_CONFLICT)
+                            open_entry,
-            else:
+                            request,
-                previous_open_entry = TimeEntry.objects.select_for_update().filter(
+                        ),
+                    }
+                )
+
+            # =====================================================
+            # SORTIE SANS ENTRÉE
+            # =====================================================
+
+            if open_exit:
+                return Response(
+                    {
+                        'error': (
+                            'Une sortie existe déjà sans entrée.'
+                        ),
+                        'conflict': 'open_exit',
+                        'resolution': 'complete_open_exit',
+                        'missing_time': 'start_time',
+                        'message': (
+                            'Une sortie existe déjà sans entrée. '
+                            'Voulez-vous renseigner l’heure d’entrée ?'
+                        ),
+                    },
+                    status=status.HTTP_409_CONFLICT,
+                )
+
+            # =====================================================
+            # POINTAGE OUVERT SUR UN JOUR PRÉCÉDENT
+            # =====================================================
+
+            previous_open_entry = (
+                TimeEntry.objects
+                .select_for_update()
+                .filter(
                     user=request.user,
                     start_time__isnull=False,
                     end_time__isnull=True,
-                ).exclude(date=now.date()).order_by('-date', '-start_time').first()
+                )
-                if previous_open_entry:
+                .exclude(
-                    last_date = previous_open_entry.date
+                    date=today,
-                    previous_open_entry.end_time = datetime_time(23, 59, 59)
+                )
-                    previous_open_entry.save(update_fields=['end_time', 'updated_at'])
+                .order_by(
+                    '-date',
+                    '-start_time',
+                )
+                .first()
+            )
 
-                    current_date = last_date + timedelta(days=1)
+            if previous_open_entry:
-                    while current_date < now.date():
+                last_date = previous_open_entry.date
-                        TimeEntry.objects.create(
-                            user=request.user,
-                            date=current_date,
-                            start_time=datetime_time.min,
-                            end_time=datetime_time(23, 59, 59),
-                        )
-                        current_date += timedelta(days=1)
 
-                    entry = TimeEntry.objects.create(user=request.user, date=now.date(), end_time=selected_time)
+                group_id = (
-                    message = 'Sortie enregistrée sur plusieurs jours.'
+                    previous_open_entry.group_id
-                else:
+                    or previous_open_entry.id
-                    entry = TimeEntry.objects.create(user=request.user, date=now.date(), end_time=selected_time)
+                )
-                    message = 'Sortie enregistrée sans entrée correspondante.'
 
-        return Response({'action': action, 'message': message, 'entry': TimeEntrySerializer(entry).data})
+                # Si l'ancien pointage n'avait pas encore de groupe,
+                # on lui attribue un UUID basé sur un nouvel objet.
+                if not previous_open_entry.group_id:
+                    import uuid
 
-class TimeEntryDetailView(generics.RetrieveUpdateDestroyAPIView):
+                    group_id = uuid.uuid4()
+
+                    previous_open_entry.group_id = group_id
+
+                previous_open_entry.end_time = datetime_time(
+                    23,
+                    59,
+                    59,
+                )
+
+                previous_open_entry.save(
+                    update_fields=[
+                        'group_id',
+                        'end_time',
+                        'updated_at',
+                    ],
+                )
+
+                current_date = (
+                    last_date
+                    + timedelta(days=1)
+                )
+
+                while current_date < today:
+                    TimeEntry.objects.create(
+                        user=request.user,
+                        group_id=group_id,
+                        date=current_date,
+                        start_time=datetime_time.min,
+                        end_time=datetime_time(
+                            23,
+                            59,
+                            59,
+                        ),
+                    )
+
+                    current_date += timedelta(
+                        days=1,
+                    )
+
+                entry = TimeEntry.objects.create(
+                    user=request.user,
+                    group_id=group_id,
+                    date=today,
+                    end_time=selected_time,
+                )
+
+                return Response(
+                    {
+                        'action': 'exit',
+                        'message': 'Sortie enregistrée sur plusieurs jours.',
+                        'entry': self._serialize_entry(
+                            entry,
+                            request,
+                        ),
+                    }
+                )
+
+            # =====================================================
+            # AUCUNE ENTRÉE
+            #
+            # On NE crée rien immédiatement.
+            # Le frontend demande d'abord confirmation.
+            # =====================================================
+
+            return Response(
+                {
+                    'error': (
+                        'Aucune entrée ouverte. '
+                        'Voulez-vous enregistrer une sortie ?'
+                    ),
+                    'conflict': 'missing_entry',
+                    'resolution': 'complete_missing_entry',
+                    'missing_time': 'start_time',
+                    'message': (
+                        'Aucune entrée ouverte. '
+                        'Voulez-vous enregistrer une sortie ?'
+                    ),
+                    'scan_time': selected_time.strftime(
+                        '%H:%M'
+                    ),
+                },
+                status=status.HTTP_409_CONFLICT,
+            )
+
+
+class TimeEntryDetailView(
+    generics.RetrieveUpdateDestroyAPIView
+):
     serializer_class = TimeEntrySerializer
     permission_classes = [IsAuthenticated]
     lookup_url_kwarg = 'entry_id'
 
     def get_queryset(self):
         user = self.request.user
-        # Staff members can view all entries, regular users only their own
+
         if user.is_staff or user.is_superuser:
             return TimeEntry.objects.all()
-        return TimeEntry.objects.filter(user=user)
+
+        return TimeEntry.objects.filter(
+            user=user,
+        )
+
 
 class TimeEntryUpdateView(APIView):
     permission_classes = [IsAuthenticated]
 
     def put(self, request, entry_id):
         try:
-            entry = TimeEntry.objects.get(id=entry_id)
+            entry = TimeEntry.objects.get(
-            # Check if user is authorized to update this entry
+                id=entry_id,
-            if not (request.user.is_staff or request.user.is_superuser or entry.user == request.user):
+            )
-                return Response(
-                    {'error': 'Accès refusé'}, 
-                    status=status.HTTP_403_FORBIDDEN
-                )
 
-            serializer = TimeEntryUpdateSerializer(entry, data=request.data)
-            if serializer.is_valid():
-                serializer.save()
-                return Response(serializer.data)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
         except TimeEntry.DoesNotExist:
             return Response(
-                {'error': 'Pointage non trouvé'}, 
+                {
-                status=status.HTTP_404_NOT_FOUND
+                    'error': 'Pointage non trouvé'
+                },
+                status=status.HTTP_404_NOT_FOUND,
             )
 
+        if not (
+            request.user.is_staff
+            or request.user.is_superuser
+            or entry.user == request.user
+        ):
+            return Response(
+                {
+                    'error': 'Accès refusé'
+                },
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        serializer = TimeEntryUpdateSerializer(
+            entry,
+            data=request.data,
+        )
+
+        if serializer.is_valid():
+            serializer.save()
+
+            return Response(
+                serializer.data,
+            )
+
+        return Response(
+            serializer.errors,
+            status=status.HTTP_400_BAD_REQUEST,
+        )
+
+
 def build_weekly_summary(user):
     today = timezone.localdate()
-    start_of_week = today - timedelta(days=today.weekday())
+
-    end_of_week = start_of_week + timedelta(days=6)
+    start_of_week = (
-    entries = list(TimeEntry.objects.filter(
+        today
-        user=user,
+        - timedelta(
-        date__range=(start_of_week, end_of_week),
+            days=today.weekday(),
-    ).order_by('date'))
+        )
+    )
+
+    end_of_week = (
+        start_of_week
+        + timedelta(days=6)
+    )
+
+    entries = list(
+        TimeEntry.objects.filter(
+            user=user,
+            date__range=(
+                start_of_week,
+                end_of_week,
+            ),
+        ).order_by(
+            'date',
+            'start_time',
+        )
+    )
+
     entries_by_date = {}
+
     for entry in entries:
-        entries_by_date.setdefault(entry.date, entry)
+        entries_by_date.setdefault(
+            entry.date,
+            entry,
+        )
 
     days_data = []
+
     for day_offset in range(7):
-        current_day = start_of_week + timedelta(days=day_offset)
+        current_day = (
-        entry = entries_by_date.get(current_day)
+            start_of_week
-        days_data.append({
+            + timedelta(
-            'date': current_day.isoformat(),
+                days=day_offset,
-            'day': current_day.strftime('%A'),
+            )
-            'start_time': str(entry.start_time) if entry and entry.start_time else None,
+        )
-            'end_time': str(entry.end_time) if entry and entry.end_time else None,
+
-            'duration': entry.duration if entry else 0,
+        entry = entries_by_date.get(
-        })
+            current_day,
+        )
+
+        days_data.append(
+            {
+                'date': current_day.isoformat(),
+                'day': current_day.strftime('%A'),
+                'start_time': (
+                    str(entry.start_time)
+                    if entry and entry.start_time
+                    else None
+                ),
+                'end_time': (
+                    str(entry.end_time)
+                    if entry and entry.end_time
+                    else None
+                ),
+                'duration': (
+                    entry.duration
+                    if entry
+                    else 0
+                ),
+            }
+        )
 
     return {
         'user': user.username,
         'username': user.username,
-        'total_hours': round(sum(entry.duration or 0 for entry in entries), 2),
+        'total_hours': round(
-        'days': days_data,
+            sum(
+                entry.duration or 0
+                for entry in entries
+            ),
+            2,
+        ),
+        'entries': days_data,
     }
 
 
@@ -249,11 +785,31 @@ class WeeklySummaryView(APIView):
 
     def get(self, request, user_id=None):
         user = request.user
-        if user_id and (request.user.is_staff or request.user.is_superuser):
-            try:
-                user = settings.AUTH_USER_MODEL.objects.get(id=user_id)
-            except settings.AUTH_USER_MODEL.DoesNotExist:
-                return Response({'error': 'Utilisateur non trouvé'}, status=status.HTTP_404_NOT_FOUND)
 
-        serializer = WeeklySummarySerializer(build_weekly_summary(user))
+        if (
-        return Response(serializer.data)
+            user_id
+            and (
+                request.user.is_staff
+                or request.user.is_superuser
+            )
+        ):
+            try:
+                user = User.objects.get(
+                    id=user_id,
+                )
+
+            except User.DoesNotExist:
+                return Response(
+                    {
+                        'error': 'Utilisateur non trouvé'
+                    },
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+
+        serializer = WeeklySummarySerializer(
+            build_weekly_summary(user),
+        )
+
+        return Response(
+            serializer.data,
+        )

frontend/src/api/time.js

@@ -1,95 +1,176 @@
 import api from './axios';
 
 export const timeApi = {
-  // Get all time entries
   getTimeEntries: async () => {
     try {
       const response = await api.get('/time/entries/');
       return response.data;
     } catch (error) {
-      throw new Error('Failed to fetch time entries: ' + error.message);
+      throw new Error(
+        'Failed to fetch time entries: ' +
+          error.message,
+      );
     }
   },
 
-  // Get all users (admin only)
   getUsers: async () => {
     try {
       const response = await api.get('/users/');
       return response.data;
     } catch (error) {
-      throw new Error('Failed to fetch users: ' + error.message);
+      throw new Error(
+        'Failed to fetch users: ' +
+          error.message,
+      );
     }
   },
 
-  // Create a new time entry
   createTimeEntry: async (entryData) => {
     try {
-      const response = await api.post('/time/entries/create/', entryData);
+      const response = await api.post(
+        '/time/entries/create/',
+        entryData,
+      );
+
       return response.data;
     } catch (error) {
-      throw new Error('Failed to create time entry: ' + error.message);
+      const message =
+        error.response?.data?.detail ||
+        error.response?.data?.error ||
+        error.message;
+
+      throw new Error(
+        "Erreur lors de la création du pointage : " +
+          message,
+      );
     }
   },
 
-  scanTimeEntry: async (code, options = {}) => {
+  scanTimeEntry: async (
+    code,
+    options = {},
+  ) => {
     try {
-      const response = await api.post('/time/entries/scan/', { code, ...options });
+      const response = await api.post(
+        '/time/entries/scan/',
+        {
+          code,
+          ...options,
+        },
+      );
+
       return response.data;
     } catch (error) {
-      const scanError = new Error(error.response?.data?.error || `Erreur lors du pointage: ${error.message}`);
+      const data =
-      scanError.conflict = error.response?.data?.conflict;
+        error.response?.data || {};
-      scanError.code = error.response?.status;
+
+      const scanError = new Error(
+        data.error ||
+          `Erreur lors du pointage: ${error.message}`,
+      );
+
+      scanError.conflict =
+        data.conflict;
+
+      scanError.resolution =
+        data.resolution;
+
+      scanError.missingTime =
+        data.missing_time;
+
+      scanError.scanTime =
+        data.scan_time;
+
+      scanError.code =
+        error.response?.status;
+
       throw scanError;
     }
   },
 
-  // Get a specific time entry
   getTimeEntry: async (id) => {
     try {
-      const response = await api.get(`/time/entries/${id}/`);
+      const response = await api.get(
+        `/time/entries/${id}/`,
+      );
+
       return response.data;
     } catch (error) {
-      throw new Error('Failed to fetch time entry: ' + error.message);
+      throw new Error(
+        'Failed to fetch time entry: ' +
+          error.message,
+      );
     }
   },
 
-  // Update a time entry
+  updateTimeEntry: async (
-  updateTimeEntry: async (id, entryData) => {
+    id,
+    entryData,
+  ) => {
     try {
-      const response = await api.put(`/time/entries/${id}/update/`, entryData);
+      const response = await api.put(
+        `/time/entries/${id}/update/`,
+        entryData,
+      );
+
       return response.data;
     } catch (error) {
-      throw new Error('Failed to update time entry: ' + error.message);
+      const message =
+        error.response?.data?.detail ||
+        error.response?.data?.error ||
+        error.message;
+
+      throw new Error(
+        'Erreur lors de la mise à jour : ' +
+          message,
+      );
     }
   },
 
-  // Delete a time entry
   deleteTimeEntry: async (id) => {
     try {
-      const response = await api.delete(`/time/entries/${id}/`);
+      const response = await api.delete(
+        `/time/entries/${id}/`,
+      );
+
       return response.data;
     } catch (error) {
-      throw new Error(error.response?.data?.detail || `Erreur lors de la suppression: ${error.message}`);
+      throw new Error(
+        error.response?.data?.detail ||
+          `Erreur lors de la suppression: ${error.message}`,
+      );
     }
   },
 
-  // Get weekly summary for current user
   getWeeklySummary: async () => {
     try {
-      const response = await api.get('/time/weekly-summary/');
+      const response = await api.get(
+        '/time/weekly-summary/',
+      );
+
       return response.data;
     } catch (error) {
-      throw new Error('Failed to fetch weekly summary: ' + error.message);
+      throw new Error(
+        'Failed to fetch weekly summary: ' +
+          error.message,
+      );
     }
   },
 
-  // Get weekly summary for a specific user (admin only)
+  getUserWeeklySummary: async (
-  getUserWeeklySummary: async (userId) => {
+    userId,
+  ) => {
     try {
-      const response = await api.get(`/time/weekly-summary/${userId}/`);
+      const response = await api.get(
+        `/time/weekly-summary/${userId}/`,
+      );
+
       return response.data;
     } catch (error) {
-      throw new Error('Failed to fetch user weekly summary: ' + error.message);
+      throw new Error(
+        'Failed to fetch user weekly summary: ' +
+          error.message,
+      );
     }
   },
 };