Finish supervisor , 残りはExcelとセキュリティ.

docker-compose.yaml

@@ -53,7 +53,9 @@ services:
         - type: volume
           source: nginx_logs
           target: /var/log/nginx
-        - media_data:/app/media:ro
+        - type: bind
+          source: ./media
+          target: /usr/share/nginx/html/media
       ports:
         - "80:80"
       depends_on:
@@ -73,4 +75,3 @@ volumes:
   geoserver-data:
   static_volume:
   nginx_logs:
-  media_data:

rog/models.py

@@ -323,6 +323,8 @@ class NewEvent2(models.Model):
     class_solo_male = models.BooleanField(default=True)
     class_solo_female = models.BooleanField(default=True)
 
+    self_rogaining = models.BooleanField(default=False)
+
     def __str__(self):
         return f"{self.event_name} - From:{self.start_datetime} To:{self.end_datetime}"
 
@@ -520,6 +522,11 @@ class GoalImages(models.Model):
     team_name = models.CharField(_("Team name"), max_length=255)
     event_code = models.CharField(_("event code"), max_length=255)
     cp_number = models.IntegerField(_("CP numner"))
+    zekken_number = models.TextField(
+        null=True,  # False にする
+        blank=True, # False にする
+        help_text="ゼッケン番号"
+    )
 
 class CheckinImages(models.Model):
     user=models.ForeignKey(CustomUser, on_delete=models.DO_NOTHING)
@@ -530,6 +537,7 @@ class CheckinImages(models.Model):
     cp_number = models.IntegerField(_("CP numner"))
 
 class GpsCheckin(models.Model):
+    id = models.AutoField(primary_key=True)  # 明示的にidフィールドを追加
     path_order = models.IntegerField(
         null=False,
         help_text="チェックポイントの順序番号"
@@ -635,7 +643,7 @@ class GpsCheckin(models.Model):
         ]
 
     def __str__(self):
-        return f"{self.event_code}-{self.zekken_number}-{self.path_order}"
+        return f"{self.event_code}-{self.zekken_number}-{self.path_order}-buy:{self.buy_flag}-valid:{self.validate_location}-point:{self.points}"
 
     def save(self, *args, **kwargs):
         # 作成時・更新時のタイムスタンプを自動設定

rog/urls.py

@@ -124,6 +124,9 @@ urlpatterns += [
     path('export_excel/<int:zekken_number>/<str:event_code>/', views.export_excel, name='export_excel'),
     # for Supervisor Web app
     path('test/', views.test_api, name='test_api'),
+    path('update-goal-time/', views.update_goal_time, name='update-goal-time'),
+    path('get-goalimage/', views.get_goalimage, name='get-goalimage'),
+
 ]
 
 if settings.DEBUG:

rog/views.py

@@ -89,6 +89,7 @@ from io import BytesIO
 
 from django.urls import get_resolver
 import os
+import json
 
 logger = logging.getLogger(__name__)
 
@@ -227,6 +228,43 @@ class LocationViewSet(viewsets.ModelViewSet):
     serializer_class=LocationSerializer
     filter_fields=["prefecture", "location_name"]
 
+    def get_queryset(self):
+        queryset = Location.objects.all()
+        logger.info("=== Location API Called ===")
+
+        # リクエストパラメータの確認
+        group_filter = self.request.query_params.get('group__contains')
+        logger.info(f"Request params: {dict(self.request.query_params)}")
+        logger.info(f"Group filter: {group_filter}")
+
+        if group_filter:
+            # フィルタ適用前のデータ数
+            total_count = queryset.count()
+            logger.info(f"Total locations before filter: {total_count}")
+
+            # フィルタの適用
+            queryset = queryset.filter(group__contains=group_filter)
+
+            # フィルタ適用後のデータ数
+            filtered_count = queryset.count()
+            logger.info(f"Filtered locations count: {filtered_count}")
+
+            # フィルタされたデータのサンプル（最初の5件）
+            sample_data = queryset[:5]
+            logger.info("Sample of filtered data:")
+            for loc in sample_data:
+                logger.info(f"ID: {loc.id}, Name: {loc.location_name}, Group: {loc.group}")
+
+        return queryset
+
+    def list(self, request, *args, **kwargs):
+        try:
+            response = super().list(request, *args, **kwargs)
+            logger.info(f"Response data count: {len(response.data['features'])}")
+            return response
+        except Exception as e:
+            logger.error(f"Error in list method: {str(e)}", exc_info=True)
+            raise
 
 class Location_lineViewSet(viewsets.ModelViewSet):
     queryset=Location_line.objects.all()
@@ -2362,18 +2400,45 @@ def get_team_info(request, zekken_number):
     entry = Entry.objects.select_related('team','event').get(zekken_number=zekken_number)
     members = Member.objects.filter(team=entry.team)
 
+    start_datetime = entry.event.start_datetime #イベントの規定スタート時刻
+    if entry.event.self_rogaining:
+        #get_checkinsの中で、
+        #  start_datetime = -1(ロゲ開始)のcreate_at
+        logger.debug(f"self.rogaining={entry.event.self_rogaining} => start_datetime = -1(ロゲ開始)のcreate_at")   
+
     # チームのゴール時間を取得
     goal_record = GoalImages.objects.filter(
         team_name=entry.team.team_name,
         event_code=entry.event.event_name
     ).order_by('-goaltime').first()
 
+    # Nullチェックを追加してからログ出力
+    goalimage_url = None
+    goaltime = None
+
+    if goal_record:
+        try:
+            goaltime = goal_record.goaltime
+            if goal_record.goalimage and hasattr(goal_record.goalimage, 'url'):
+                goalimage_url = request.build_absolute_uri(goal_record.goalimage.url)
+                logger.info(f"get_team_info record.goalimage_url={goalimage_url}")
+            else:
+                logger.info("Goal record exists but no image found")
+                
+        except ValueError as e:
+            logger.warning(f"Error accessing goal image: {str(e)}")
+    else:
+        logger.info("No goal record found for team")
+
+
     return Response({
         'team_name': entry.team.team_name,
         'members': ', '.join([f"{m.lastname} {m.firstname}" for m in members]),
         'event_code': entry.event.event_name,
         'start_datetime': entry.event.start_datetime,
-        'end_datetime': goal_record.goaltime if goal_record else None
+        'end_datetime': goaltime, #goal_record.goaltime if goal_record else None,
+        'goal_photo': goalimage_url, #goal_record.goalimage if goal_record else None,
+        'duration': entry.category.duration.total_seconds()   
     })
 
     def create(self, request, *args, **kwargs):
@@ -2468,20 +2533,80 @@ def get_checkins(request, *args, **kwargs):
             status=status.HTTP_500_INTERNAL_SERVER_ERROR
         )
 
+
 @api_view(['POST'])
 def update_checkins(request):
-    with transaction.atomic():
+    try:
-        for update in request.data:
+        with transaction.atomic():
-            checkin = GpsCheckin.objects.get(id=update['id'])
+            update_base = request.data
-            checkin.path_order = update['path_order']
+            logger.info(f"Processing update data: {update_base}")
-            checkin.validate_location = update['validate_location']
+            zekken_number = update_base['zekken_number']
-            checkin.save()
+            event_code = update_base['event_code']
-    return Response({'status': 'success'})
+
+            for update in update_base['checkins']:
+                if 'id' in update and int(update['id'])>0:
+                    # 既存レコードの更新
+                    logger.info(f"Updating existing checkin : {update}")
+                    try:
+                        checkin = GpsCheckin.objects.get(id=update['id'])
+                        logger.info(f"Updating existing checkin: {checkin}")
+                        
+                        # 既存レコードの更新
+                        checkin.path_order = update['order']
+                        checkin.buy_flag = update.get('buy_flag', False)
+                        checkin.validate_location = update.get('validation', False)
+                        checkin.points = update.get('points', 0)
+                        checkin.save()
+                        logger.info(f"Updated existing checkin result: {checkin}")
+                        
+                    except GpsCheckin.DoesNotExist:
+                        logger.error(f"Checkin with id {update['id']} not found")
+                        return Response(
+                            {"error": f"Checkin with id {update['id']} not found"}, 
+                            status=status.HTTP_404_NOT_FOUND
+                        )
+            for update in update_base['checkins']:
+                if 'id' in update and int(update['id'])==0:
+                    # 新規レコードの作成
+                    logger.info("Creating new checkin:{update}")
+                    try:
+                        checkin = GpsCheckin.objects.create(
+                            zekken_number=update_base['zekken_number'],
+                            event_code=update_base['event_code'],
+
+                            path_order=update['order'],
+                            cp_number=update['cp_number'],
+                            validate_location=update.get('validation', False),
+                            buy_flag=update.get('buy_flag', False),
+                            points=update.get('points', 0),
+                            create_at=timezone.now(),
+                            update_at=timezone.now(),
+                            create_user=request.user.email if request.user.is_authenticated else None,
+                            update_user=request.user.email if request.user.is_authenticated else None
+                        )
+                        logger.info(f"Updated existing checkin result: {checkin}")
+                    
+                    except KeyError as e:
+                        logger.error(f"Missing required field: {str(e)}")
+                        return Response(
+                            {"error": f"Missing required field: {str(e)}"}, 
+                            status=status.HTTP_400_BAD_REQUEST
+                        )
+
+        return Response({'status': 'success', 'message': 'Checkins updated successfully'})
+    
+    except Exception as e:
+        logger.error(f"Error in update_checkins: {str(e)}", exc_info=True)
+        return Response(
+            {"error": "Failed to update checkins", "detail": str(e)}, 
+            status=status.HTTP_500_INTERNAL_SERVER_ERROR
+        )
+
 
 @api_view(['GET'])
 def export_excel(request, zekken_number):
     # エントリー情報の取得
-    entry = Entry.objects.select_related('team').get(zekken_number=zekken_number)
+    entry = Entry.objects.select_related('team','event').get(zekken_number=zekken_number)
     checkins = GpsCheckin.objects.filter(zekken_number=zekken_number).order_by('path_order')
 
     # Excelファイルの生成
@@ -2532,3 +2657,145 @@ def test_api(request):
     logger.debug("Test API endpoint called")
     return JsonResponse({"status": "API is working"})
 
+@api_view(['GET'])
+#@authentication_classes([TokenAuthentication])
+#@permission_classes([IsAuthenticated])
+def get_goalimage(request):
+    """
+    ゼッケン番号とイベントコードに基づいてゴール画像情報を取得するエンドポイント
+    
+    Parameters:
+        zekken_number (str): ゼッケン番号
+        event_code (str): イベントコード
+    
+    Returns:
+        Response: ゴール画像情報を含むJSONレスポンス
+    """
+    try:
+        logger.debug(f"get_goalimage called with params: {request.GET}")
+
+        # リクエストパラメータを取得
+        zekken_number = request.GET.get('zekken_number')
+        event_code = request.GET.get('event_code')
+
+        logger.debug(f"Searching for goal records with zekken_number={zekken_number}, event_code={event_code}")
+
+        # パラメータの検証
+        if not zekken_number or not event_code:
+            return Response(
+                {"error": "zekken_number and event_code are required"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        # ゴール画像レコードを検索（最も早いゴール時間のレコードを取得）
+        goal_records = GoalImages.objects.filter(
+            zekken_number=zekken_number,
+            event_code=event_code
+        ).order_by('goaltime')
+
+        logger.debug(f"Found {goal_records.count()} goal records")
+
+        if not goal_records.exists():
+            return Response(
+                {"message": "No goal records found"},
+                status=status.HTTP_404_NOT_FOUND
+            )
+
+        # 最も早いゴール時間のレコード（cp_number = 0）を探す
+        valid_goal = goal_records.filter(cp_number=0).first()
+        
+        if not valid_goal:
+            return Response(
+                {"message": "No valid goal record found"},
+                status=status.HTTP_404_NOT_FOUND
+            )
+
+        # シリアライザでデータを整形
+        serializer = GolaImageSerializer(valid_goal)
+        
+        # レスポンスデータの構築
+        response_data = {
+            "goal_record": serializer.data,
+            "total_records": goal_records.count(),
+            "has_multiple_records": goal_records.count() > 1
+        }
+
+        logger.info(f"Retrieved goal record for zekken_number {zekken_number} in event {event_code}")
+        return Response(response_data)
+
+    except Exception as e:
+        logger.error(f"Error retrieving goal record: {str(e)}", exc_info=True)
+        return Response(
+            {"error": f"Failed to retrieve goal record: {str(e)}"},
+            status=status.HTTP_500_INTERNAL_SERVER_ERROR
+        )
+
+
+@api_view(['POST'])
+#@authentication_classes([TokenAuthentication])
+#@permission_classes([IsAuthenticated])
+def update_goal_time(request):
+    try:
+        logger.info(f"update_goal_time:{request}")
+        # リクエストからデータを取得
+        zekken_number = request.data.get('zekken_number')
+        event_code = request.data.get('event_code')
+        team_name = request.data.get('team_name')
+        goal_time_str = request.data.get('goaltime')
+
+        logger.info(f"zekken_number={zekken_number},event_code={event_code},team_name={team_name},goal_time={goal_time_str}")
+
+        # 入力バリデーション
+        #if not all([zekken_number, event_code, team_name, goal_time_str]):
+        #    return Response(
+        #        {"error": "Missing required fields"},
+        #        status=status.HTTP_400_BAD_REQUEST
+        #    )
+
+        try:
+            # 文字列からdatetimeオブジェクトに変換
+            goal_time = datetime.strptime(goal_time_str, '%Y-%m-%dT%H:%M:%S')
+        except ValueError:
+            return Response(
+                {"error": "Invalid goal time format"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        # 既存のゴール記録を探す
+        goal_record = GoalImages.objects.filter(
+            team_name=team_name,
+            event_code=event_code
+        ).first()
+
+        if goal_record:
+            # 既存の記録を更新
+            goal_record.goaltime = goal_time
+            goal_record.save()
+            logger.info(f"Updated goal time for team {team_name} in event {event_code}")
+        else:
+            # 新しい記録を作成
+            entry = Entry.objects.get(zekken_number=zekken_number, event__event_name=event_code)
+            GoalImages.objects.create(
+                user=entry.owner,
+                goaltime=goal_time,
+                team_name=team_name,
+                event_code=event_code,
+                cp_number=0  # ゴール地点を表すCP番号
+            )
+            logger.info(f"Created new goal time record for team {team_name} in event {event_code}")
+
+        return Response({"message": "Goal time updated successfully"})
+
+    except Entry.DoesNotExist:
+        logger.error(f"Entry not found for zekken_number {zekken_number} in event {event_code}")
+        return Response(
+            {"error": "Entry not found"},
+            status=status.HTTP_404_NOT_FOUND
+        )
+    except Exception as e:
+        logger.error(f"Error updating goal time: {str(e)}")
+        return Response(
+            {"error": f"Failed to update goal time: {str(e)}"},
+            status=status.HTTP_500_INTERNAL_SERVER_ERROR
+        )
+