""" 写真一括アップロード・通過履歴校正API スマホアルバムから複数の写真をアップロードし、EXIF情報から自動的に通過履歴を生成・校正する """ import logging import uuid import os from datetime import datetime from django.http import JsonResponse from django.utils import timezone from django.db import transaction from django.core.files.storage import default_storage from django.conf import settings from rest_framework.decorators import api_view, permission_classes, parser_classes from rest_framework.permissions import IsAuthenticated from rest_framework.response import Response from rest_framework import status from rest_framework.parsers import MultiPartParser, FormParser from knox.auth import TokenAuthentication from PIL import Image from PIL.ExifTags import TAGS, GPSTAGS import math from ..models import NewEvent2, Entry, GpsLog, Location2025, GpsCheckin # ログ設定 logger = logging.getLogger(__name__) def extract_exif_data(image_file): """ 画像ファイルからEXIF情報を抽出する Returns: dict: { 'latitude': float, 'longitude': float, 'datetime': datetime, 'has_gps': bool } """ try: # PIL Imageオブジェクトを作成 image = Image.open(image_file) # EXIF情報を取得 exif_data = image._getexif() if not exif_data: logger.warning(f"No EXIF data found in image: {image_file.name}") return {'has_gps': False, 'latitude': None, 'longitude': None, 'datetime': None} # GPS情報とDatetime情報を抽出 gps_info = {} datetime_original = None for tag_id, value in exif_data.items(): tag = TAGS.get(tag_id, tag_id) if tag == "GPSInfo": # GPS情報の詳細を展開 for gps_tag_id, gps_value in value.items(): gps_tag = GPSTAGS.get(gps_tag_id, gps_tag_id) gps_info[gps_tag] = gps_value elif tag == "DateTime" or tag == "DateTimeOriginal": try: datetime_original = datetime.strptime(str(value), '%Y:%m:%d %H:%M:%S') except ValueError: logger.warning(f"Failed to parse datetime: {value}") # GPS座標の変換 latitude = None longitude = None if 'GPSLatitude' in gps_info and 'GPSLongitude' in gps_info: lat_deg, lat_min, lat_sec = gps_info['GPSLatitude'] lon_deg, lon_min, lon_sec = gps_info['GPSLongitude'] # 度分秒を小数度に変換 latitude = float(lat_deg) + float(lat_min)/60 + float(lat_sec)/3600 longitude = float(lon_deg) + float(lon_min)/60 + float(lon_sec)/3600 # 南緯・西経の場合は負の値にする if gps_info.get('GPSLatitudeRef') == 'S': latitude = -latitude if gps_info.get('GPSLongitudeRef') == 'W': longitude = -longitude logger.info(f"EXIF extracted from {image_file.name}: lat={latitude}, lon={longitude}, datetime={datetime_original}") return { 'has_gps': latitude is not None and longitude is not None, 'latitude': latitude, 'longitude': longitude, 'datetime': datetime_original } except Exception as e: logger.error(f"Error extracting EXIF from {image_file.name}: {str(e)}") return {'has_gps': False, 'latitude': None, 'longitude': None, 'datetime': None} def find_nearest_checkpoint(latitude, longitude, event_code, max_distance_m=100): """ 指定された座標から最も近いチェックポイントを検索する Args: latitude: 緯度 longitude: 経度 event_code: イベントコード max_distance_m: 最大距離（メートル） Returns: Location2025オブジェクトまたはNone """ try: # 該当イベントのチェックポイントを取得 checkpoints = Location2025.objects.filter(event__event_name=event_code) if not checkpoints.exists(): logger.warning(f"No checkpoints found for event: {event_code}") return None # 最も近いチェックポイントを検索 nearest_cp = None min_distance = float('inf') for cp in checkpoints: if cp.latitude and cp.longitude: # ハーバーサイン距離の計算 distance = calculate_distance(latitude, longitude, cp.latitude, cp.longitude) if distance < min_distance and distance <= max_distance_m: min_distance = distance nearest_cp = cp if nearest_cp: logger.info(f"Found nearest checkpoint: {nearest_cp.location} (CP{nearest_cp.cp_number}) at distance {min_distance:.1f}m") else: logger.info(f"No checkpoint found within {max_distance_m}m of lat={latitude}, lon={longitude}") return nearest_cp except Exception as e: logger.error(f"Error finding nearest checkpoint: {str(e)}") return None def calculate_distance(lat1, lon1, lat2, lon2): """ ハーバーサイン公式を使用して2点間の距離を計算（メートル単位） """ R = 6371000 # 地球の半径（メートル） lat1_rad = math.radians(lat1) lat2_rad = math.radians(lat2) delta_lat = math.radians(lat2 - lat1) delta_lon = math.radians(lon2 - lon1) a = (math.sin(delta_lat/2) * math.sin(delta_lat/2) + math.cos(lat1_rad) * math.cos(lat2_rad) * math.sin(delta_lon/2) * math.sin(delta_lon/2)) c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a)) distance = R * c return distance def create_checkin_from_photo(entry, checkpoint, photo_datetime, zekken_number, event_code, photo_filename, request_id): """ 写真情報からチェックインデータを作成する Args: entry: Entryオブジェクト checkpoint: Location2025オブジェクト photo_datetime: 撮影日時 zekken_number: ゼッケン番号 event_code: イベントコード photo_filename: 写真ファイル名 request_id: リクエストID Returns: GpsCheckinオブジェクトまたはNone """ try: # 既存のチェックインをチェック（重複防止） existing_checkin = GpsCheckin.objects.filter( zekken=str(zekken_number), event_code=event_code, cp_number=checkpoint.cp_number ).first() if existing_checkin: logger.info(f"[BULK_UPLOAD] 📍 Existing checkin found - ID: {request_id}, CP: {checkpoint.cp}, existing_id: {existing_checkin.id}") return existing_checkin # 新規チェックインの作成 # 撮影時刻をJSTに変換 if photo_datetime: # 撮影時刻をUTCとして扱い、JSTに変換 create_at = timezone.make_aware(photo_datetime, timezone.utc) else: create_at = timezone.now() # シリアル番号を決定（既存のチェックイン数+1） existing_count = GpsCheckin.objects.filter( zekken=str(zekken_number), event_code=event_code ).count() serial_number = existing_count + 1 # チェックインデータを作成 checkin = GpsCheckin.objects.create( zekken=str(zekken_number), event_code=event_code, cp_number=checkpoint.cp_number, serial_number=serial_number, create_at=create_at, update_at=timezone.now(), validate_location=True, # 写真から作成されたものは自動承認 buy_flag=False, points=checkpoint.checkin_point if checkpoint.checkin_point else 0, create_user=f"bulk_upload_{request_id}", # 一括アップロードで作成されたことを示す update_user=f"bulk_upload_{request_id}", photo_source=photo_filename # 元画像ファイル名を記録（カスタムフィールドがあれば） ) logger.info(f"[BULK_UPLOAD] ✅ Created checkin - ID: {request_id}, checkin_id: {checkin.id}, CP: {checkpoint.cp_number}, time: {create_at}, points: {checkin.points}") return checkin except Exception as e: logger.error(f"[BULK_UPLOAD] ❌ Error creating checkin - ID: {request_id}, CP: {checkpoint.cp_number if checkpoint else 'None'}, error: {str(e)}") return None @api_view(['POST', 'GET']) @permission_classes([IsAuthenticated]) @parser_classes([MultiPartParser, FormParser]) def bulk_upload_checkin_photos(request): """ スマホアルバムから複数の写真を一括アップロードし、EXIF情報から通過履歴を校正する パラメータ: - event_code: イベントコード (必須) - zekken_number: ゼッケン番号 (必須) - photos: アップロードする写真ファイルのリスト (必須) - auto_process: 自動処理を行うかどうか (デフォルト: true) """ # リクエストID生成（デバッグ用） request_id = str(uuid.uuid4())[:8] client_ip = request.META.get('HTTP_X_FORWARDED_FOR', request.META.get('REMOTE_ADDR', 'Unknown')) logger.info(f"[BULK_UPLOAD] 🎯 API ACCESS CONFIRMED - bulk_upload_checkin_photos called successfully - ID: {request_id}, Method: {request.method}, User: {request.user.email if request.user.is_authenticated else 'Anonymous'}, Client IP: {client_ip}") logger.info(f"[BULK_UPLOAD] 🔍 Request details - Content-Type: {request.content_type}, POST data keys: {list(request.POST.keys())}, FILES count: {len(request.FILES)}") # GETリクエストの場合は、APIが動作していることを確認するための情報を返す if request.method == 'GET': logger.info(f"[BULK_UPLOAD] 📋 GET request received - returning API status") return Response({ "status": "ACTIVE", "message": "一括写真アップロードAPIが動作中です", "endpoint": "/api/bulk_upload_checkin_photos/", "method": "POST", "required_params": ["event_code", "zekken_number", "photos"], "optional_params": ["auto_process", "skip_team_validation"], "features": [ "写真からEXIF情報を抽出", "GPS座標から最寄りチェックポイントを自動検索", "撮影時刻を使用してチェックインデータを自動作成", "チーム検証機能" ], "user": request.user.email if request.user.is_authenticated else 'Not authenticated' }, status=status.HTTP_200_OK) try: # リクエストデータの取得 event_code = request.POST.get('event_code') zekken_number = request.POST.get('zekken_number') auto_process = request.POST.get('auto_process', 'true').lower() == 'true' skip_team_validation = request.POST.get('skip_team_validation', 'false').lower() == 'true' # アップロードされた写真ファイルの取得 uploaded_files = request.FILES.getlist('photos') logger.info(f"[BULK_UPLOAD] 📝 Request data - ID: {request_id}, event_code: '{event_code}', zekken_number: '{zekken_number}', files_count: {len(uploaded_files)}, auto_process: {auto_process}, skip_team_validation: {skip_team_validation}") # 必須パラメータの検証 if not all([event_code, zekken_number]): logger.warning(f"[BULK_UPLOAD] ❌ Missing required parameters - ID: {request_id}") return Response({ "status": "ERROR", "message": "イベントコードとゼッケン番号が必要です" }, status=status.HTTP_400_BAD_REQUEST) if not uploaded_files: logger.warning(f"[BULK_UPLOAD] ❌ No files uploaded - ID: {request_id}") return Response({ "status": "ERROR", "message": "アップロードする写真が必要です" }, status=status.HTTP_400_BAD_REQUEST) # ファイル数制限の確認 max_files = getattr(settings, 'BULK_UPLOAD_MAX_FILES', 50) if len(uploaded_files) > max_files: logger.warning(f"[BULK_UPLOAD] ❌ Too many files - ID: {request_id}, count: {len(uploaded_files)}, max: {max_files}") return Response({ "status": "ERROR", "message": f"一度にアップロードできる写真は最大{max_files}枚です" }, status=status.HTTP_400_BAD_REQUEST) # イベントの存在確認 event = NewEvent2.objects.filter(event_name=event_code).first() if not event: logger.warning(f"[BULK_UPLOAD] ❌ Event not found - ID: {request_id}, event_code: '{event_code}'") return Response({ "status": "ERROR", "message": "指定されたイベントが見つかりません" }, status=status.HTTP_404_NOT_FOUND) logger.info(f"[BULK_UPLOAD] ✅ Event found - ID: {request_id}, event: '{event_code}', event_id: {event.id}") # チームの存在確認とオーナー権限の検証 # zekken_numberは文字列と数値の両方で検索を試行 entry = None # まず数値として検索 if zekken_number.isdigit(): entry = Entry.objects.filter( event=event, zekken_number=int(zekken_number) ).select_related('team').first() # 見つからない場合は文字列として検索 if not entry: entry = Entry.objects.filter( event=event, zekken_label=zekken_number ).select_related('team').first() # さらに見つからない場合は文字列での zekken_number 検索 if not entry: entry = Entry.objects.filter( event=event, zekken_number=zekken_number ).select_related('team').first() logger.info(f"[BULK_UPLOAD] 🔍 Team search - ID: {request_id}, searching for zekken: '{zekken_number}', found entry: {entry.id if entry else 'None'}") # チーム検証のスキップまたは失敗処理 if not entry and not skip_team_validation: logger.warning(f"[BULK_UPLOAD] ❌ Team not found - ID: {request_id}, zekken_number: '{zekken_number}', event_code: '{event_code}'") return Response({ "status": "ERROR", "message": "指定されたゼッケン番号のチームが見つかりません" }, status=status.HTTP_404_NOT_FOUND) elif not entry and skip_team_validation: logger.warning(f"[BULK_UPLOAD] ⚠️ Team not found but validation skipped - ID: {request_id}, zekken_number: '{zekken_number}', event_code: '{event_code}'") # ダミーエントリ情報を作成（テスト用） entry = type('Entry', (), { 'id': f'test_{request_id}', 'team': type('Team', (), { 'team_name': f'Test Team {zekken_number}', 'owner': request.user })(), 'event': event })() logger.info(f"[BULK_UPLOAD] 🧪 Using test entry - ID: {request_id}, test_entry_id: {entry.id}") if hasattr(entry, 'id') and str(entry.id).startswith('test_'): logger.info(f"[BULK_UPLOAD] ✅ Test team found - ID: {request_id}, team_name: '{entry.team.team_name}', zekken: {zekken_number}, test_entry_id: {entry.id}") else: logger.info(f"[BULK_UPLOAD] ✅ Team found - ID: {request_id}, team_name: '{entry.team.team_name}', zekken: {zekken_number}, entry_id: {entry.id}") # オーナー権限の確認 (テストモードではスキップ) if not skip_team_validation and hasattr(entry, 'owner') and entry.owner != request.user: logger.warning(f"[BULK_UPLOAD] ❌ Permission denied - ID: {request_id}, user: {request.user.email}, team_owner: {entry.owner.email}") return Response({ "status": "ERROR", "message": "このチームの写真をアップロードする権限がありません" }, status=status.HTTP_403_FORBIDDEN) # 写真処理の準備 processed_files = [] successful_uploads = 0 failed_uploads = 0 # アップロードディレクトリの準備 upload_dir = f"bulk_checkin_photos/{event_code}/{zekken_number}/" os.makedirs(os.path.join(settings.MEDIA_ROOT, upload_dir), exist_ok=True) with transaction.atomic(): for index, uploaded_file in enumerate(uploaded_files): file_result = { "filename": uploaded_file.name, "file_index": index + 1, "file_size": uploaded_file.size, "upload_time": timezone.now().strftime("%Y-%m-%d %H:%M:%S") } try: # ファイル形式の確認 allowed_extensions = ['.jpg', '.jpeg', '.png', '.heic'] file_extension = os.path.splitext(uploaded_file.name)[1].lower() if file_extension not in allowed_extensions: file_result.update({ "status": "failed", "error": f"サポートされていないファイル形式: {file_extension}" }) failed_uploads += 1 processed_files.append(file_result) continue # ファイルサイズの確認 max_size = getattr(settings, 'BULK_UPLOAD_MAX_FILE_SIZE', 10 * 1024 * 1024) # 10MB if uploaded_file.size > max_size: file_result.update({ "status": "failed", "error": f"ファイルサイズが大きすぎます: {uploaded_file.size / (1024*1024):.1f}MB" }) failed_uploads += 1 processed_files.append(file_result) continue # ファイルの保存 timestamp = timezone.now().strftime("%Y%m%d_%H%M%S") safe_filename = f"{timestamp}_{index+1:03d}_{uploaded_file.name}" file_path = os.path.join(upload_dir, safe_filename) # ファイル保存 saved_path = default_storage.save(file_path, uploaded_file) full_path = os.path.join(settings.MEDIA_ROOT, saved_path) file_result.update({ "status": "uploaded", "saved_path": saved_path, "file_url": f"{settings.MEDIA_URL}{saved_path}" }) # EXIF情報の抽出とチェックイン作成 if auto_process: logger.info(f"[BULK_UPLOAD] 🔍 Starting EXIF processing for {uploaded_file.name}") # ファイルポインタを先頭に戻す uploaded_file.seek(0) # EXIF情報の抽出 exif_data = extract_exif_data(uploaded_file) if exif_data['has_gps']: logger.info(f"[BULK_UPLOAD] 📍 GPS data found - lat: {exif_data['latitude']}, lon: {exif_data['longitude']}, datetime: {exif_data['datetime']}") # 最も近いチェックポイントを検索 nearest_checkpoint = find_nearest_checkpoint( exif_data['latitude'], exif_data['longitude'], event_code ) if nearest_checkpoint: # チェックインデータを作成 checkin = create_checkin_from_photo( entry, nearest_checkpoint, exif_data['datetime'], zekken_number, event_code, uploaded_file.name, request_id ) if checkin: file_result.update({ "auto_process_status": "success", "auto_process_message": f"チェックイン作成完了", "checkin_info": { "checkpoint_name": nearest_checkpoint.location, "cp_number": nearest_checkpoint.cp_number, "points": checkin.points, "checkin_time": checkin.create_at.strftime("%Y-%m-%d %H:%M:%S"), "checkin_id": checkin.id }, "gps_info": { "latitude": exif_data['latitude'], "longitude": exif_data['longitude'], "photo_datetime": exif_data['datetime'].strftime("%Y-%m-%d %H:%M:%S") if exif_data['datetime'] else None } }) else: file_result.update({ "auto_process_status": "failed", "auto_process_message": "チェックイン作成に失敗しました", "checkpoint_info": { "checkpoint_name": nearest_checkpoint.location, "cp_number": nearest_checkpoint.cp_number } }) else: file_result.update({ "auto_process_status": "no_checkpoint", "auto_process_message": "近くにチェックポイントが見つかりませんでした", "gps_info": { "latitude": exif_data['latitude'], "longitude": exif_data['longitude'], "photo_datetime": exif_data['datetime'].strftime("%Y-%m-%d %H:%M:%S") if exif_data['datetime'] else None } }) else: file_result.update({ "auto_process_status": "no_gps", "auto_process_message": "GPS情報が見つかりませんでした", "exif_info": { "has_datetime": exif_data['datetime'] is not None, "photo_datetime": exif_data['datetime'].strftime("%Y-%m-%d %H:%M:%S") if exif_data['datetime'] else None } }) successful_uploads += 1 logger.info(f"[BULK_UPLOAD] ✅ File uploaded - ID: {request_id}, filename: {uploaded_file.name}, size: {uploaded_file.size}") except Exception as file_error: file_result.update({ "status": "failed", "error": f"ファイル処理エラー: {str(file_error)}" }) failed_uploads += 1 logger.error(f"[BULK_UPLOAD] ❌ File processing error - ID: {request_id}, filename: {uploaded_file.name}, error: {str(file_error)}") processed_files.append(file_result) # 処理結果のサマリー logger.info(f"[BULK_UPLOAD] ✅ Upload completed - ID: {request_id}, successful: {successful_uploads}, failed: {failed_uploads}") # 成功レスポンス return Response({ "status": "OK", "message": "写真の一括アップロードとチェックイン処理が完了しました", "upload_summary": { "total_files": len(uploaded_files), "successful_uploads": successful_uploads, "failed_uploads": failed_uploads, "upload_time": timezone.now().strftime("%Y-%m-%d %H:%M:%S") }, "team_info": { "team_name": entry.team.team_name, "zekken_number": zekken_number, "event_code": event_code }, "processed_files": processed_files, "auto_process_enabled": auto_process, "processing_summary": { "gps_found": len([f for f in processed_files if f.get('auto_process_status') == 'success']), "checkins_created": len([f for f in processed_files if f.get('checkin_info')]), "no_gps": len([f for f in processed_files if f.get('auto_process_status') == 'no_gps']), "no_checkpoint": len([f for f in processed_files if f.get('auto_process_status') == 'no_checkpoint']) } }) except Exception as e: logger.error(f"[BULK_UPLOAD] 💥 Unexpected error - ID: {request_id}, error: {str(e)}", exc_info=True) return Response({ "status": "ERROR", "message": "サーバーエラーが発生しました" }, status=status.HTTP_500_INTERNAL_SERVER_ERROR) @api_view(['GET']) @permission_classes([IsAuthenticated]) def get_bulk_upload_status(request): """ 一括アップロードの処理状況を取得する パラメータ: - event_code: イベントコード (必須) - zekken_number: ゼッケン番号 (必須) """ request_id = str(uuid.uuid4())[:8] logger.info(f"[BULK_STATUS] 🎯 API call started - ID: {request_id}, User: {request.user.email}") try: event_code = request.GET.get('event_code') zekken_number = request.GET.get('zekken_number') if not all([event_code, zekken_number]): return Response({ "status": "ERROR", "message": "イベントコードとゼッケン番号が必要です" }, status=status.HTTP_400_BAD_REQUEST) # チーム権限の確認 event = NewEvent2.objects.filter(event_name=event_code).first() if not event: return Response({ "status": "ERROR", "message": "指定されたイベントが見つかりません" }, status=status.HTTP_404_NOT_FOUND) entry = Entry.objects.filter(event=event, team__zekken_number=zekken_number).first() if not entry or entry.owner != request.user: return Response({ "status": "ERROR", "message": "このチームの情報にアクセスする権限がありません" }, status=status.HTTP_403_FORBIDDEN) # TODO: 実際の処理状況を取得 # TODO: アップロードされたファイル一覧 # TODO: EXIF解析状況 # TODO: 自動チェックイン生成状況 return Response({ "status": "OK", "team_info": { "team_name": entry.team.team_name, "zekken_number": zekken_number, "event_code": event_code }, "upload_status": { "total_uploaded_files": 0, "processed_files": 0, "pending_files": 0, "auto_checkins_generated": 0, "manual_review_required": 0 }, "implementation_status": "基本機能実装完了、詳細処理は今後実装予定" }) except Exception as e: logger.error(f"[BULK_STATUS] 💥 Unexpected error - ID: {request_id}, error: {str(e)}", exc_info=True) return Response({ "status": "ERROR", "message": "サーバーエラーが発生しました" }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)