""" 写真一括アップロード・通過履歴校正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 import tempfile import json from ..models import NewEvent2, Entry, GpsLog, Location2025, GpsCheckin, CheckinImages # ログ設定 logger = logging.getLogger(__name__) def upload_photo_to_s3(uploaded_file, event_code, zekken_number, cp_number=None, request_id=None): """ アップロードされた写真をS3にアップロードする Args: uploaded_file: アップロードされたファイル event_code: イベントコード zekken_number: ゼッケン番号 cp_number: チェックポイント番号 request_id: リクエストID Returns: dict: { 'success': bool, 's3_url': str, 's3_key': str, 'error': str } """ try: # S3のバケット設定を取得 bucket_name = getattr(settings, 'AWS_STORAGE_BUCKET_NAME', 'rogaining-images') # S3キーの生成 timestamp = timezone.now().strftime("%Y%m%d_%H%M%S") file_extension = os.path.splitext(uploaded_file.name)[1].lower() if cp_number: s3_key = f"checkin_photos/{event_code}/{zekken_number}/CP{cp_number}_{timestamp}_{request_id}{file_extension}" else: s3_key = f"bulk_upload/{event_code}/{zekken_number}/{timestamp}_{request_id}_{uploaded_file.name}" # 一時ファイルとして保存 with tempfile.NamedTemporaryFile(delete=False, suffix=file_extension) as temp_file: for chunk in uploaded_file.chunks(): temp_file.write(chunk) temp_file_path = temp_file.name try: # AWS認証情報の確認 aws_access_key = getattr(settings, 'AWS_ACCESS_KEY_ID', None) aws_secret_key = getattr(settings, 'AWS_SECRET_ACCESS_KEY', None) if not aws_access_key or not aws_secret_key: logger.warning(f"[S3_UPLOAD] ❌ AWS credentials not configured, falling back to local storage") return { 'success': False, 's3_url': None, 's3_key': None, 'error': 'AWS credentials not configured, using local storage instead' } # S3クライアントの設定（環境変数から取得） import boto3 from botocore.exceptions import ClientError, NoCredentialsError, PartialCredentialsError s3_client = boto3.client( 's3', aws_access_key_id=aws_access_key, aws_secret_access_key=aws_secret_key, region_name=getattr(settings, 'AWS_S3_REGION_NAME', 'ap-northeast-1') ) # S3にアップロード s3_client.upload_file( temp_file_path, bucket_name, s3_key, ExtraArgs={ 'ContentType': uploaded_file.content_type, 'Metadata': { 'event_code': event_code, 'zekken_number': str(zekken_number), 'cp_number': str(cp_number) if cp_number else '', 'original_filename': uploaded_file.name, 'upload_source': 'bulk_upload_api' } } ) # S3 URLの生成 s3_url = f"https://{bucket_name}.s3.{getattr(settings, 'AWS_S3_REGION_NAME', 'ap-northeast-1')}.amazonaws.com/{s3_key}" logger.info(f"[S3_UPLOAD] ✅ Successfully uploaded to S3 - key: {s3_key}") return { 'success': True, 's3_url': s3_url, 's3_key': s3_key, 'error': None } finally: # 一時ファイルを削除 if os.path.exists(temp_file_path): os.unlink(temp_file_path) except ImportError: logger.warning(f"[S3_UPLOAD] ❌ boto3 not available, saving locally") return { 'success': False, 's3_url': None, 's3_key': None, 'error': 'S3 upload not available (boto3 not installed)' } except Exception as e: error_message = str(e) if 'credentials' in error_message.lower(): logger.warning(f"[S3_UPLOAD] ❌ AWS credentials error: {error_message}") return { 'success': False, 's3_url': None, 's3_key': None, 'error': f'AWS credentials error: {error_message}' } else: logger.error(f"[S3_UPLOAD] ❌ Error uploading to S3: {error_message}") return { 'success': False, 's3_url': None, 's3_key': None, 'error': str(e) } def create_checkin_image_record(gps_checkin, s3_url, s3_key, original_filename, exif_data, request_id, user): """ CheckinImagesテーブルにレコードを作成する Args: gps_checkin: GpsCheckinオブジェクト s3_url: S3のURL s3_key: S3のキー original_filename: 元のファイル名 exif_data: EXIF情報 request_id: リクエストID user: ユーザーオブジェクト Returns: CheckinImagesオブジェクトまたはNone """ try: # S3 URLがない場合はローカルパスまたは一時的なプレースホルダーを使用 image_url = s3_url if s3_url else f"local://bulk_upload/{original_filename}" # CheckinImagesレコードを作成 checkin_image = CheckinImages.objects.create( user=user, checkinimage=image_url, # S3のURLまたはローカルパスを保存 checkintime=timezone.now(), team_name=f"Team_{gps_checkin.zekken}", # ゼッケン番号からチーム名を生成 event_code=gps_checkin.event_code, cp_number=gps_checkin.cp_number ) if s3_url: logger.info(f"[CHECKIN_IMAGE] ✅ Created CheckinImages record with S3 URL - ID: {checkin_image.id}, checkin_id: {gps_checkin.id}") else: logger.info(f"[CHECKIN_IMAGE] ✅ Created CheckinImages record with local path - ID: {checkin_image.id}, checkin_id: {gps_checkin.id}") return checkin_image except Exception as e: logger.error(f"[CHECKIN_IMAGE] ❌ Error creating CheckinImages record: {str(e)}") return None 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, uploaded_file, exif_data, request_id, user): """ 写真情報からチェックインデータを作成し、S3アップロードとCheckinImages登録も行う Args: entry: Entryオブジェクト checkpoint: Location2025オブジェクト photo_datetime: 撮影日時 zekken_number: ゼッケン番号 event_code: イベントコード uploaded_file: アップロードされたファイル exif_data: EXIF情報辞書 request_id: リクエストID user: ユーザーオブジェクト Returns: dict: { 'gps_checkin': GpsCheckinオブジェクト, 'checkin_image': CheckinImagesオブジェクト, 's3_info': S3アップロード情報, 'created': bool } """ try: # 既存のチェックインをチェック（重複防止） existing_checkin = GpsCheckin.objects.filter( zekken=str(zekken_number), event_code=event_code, cp_number=checkpoint.cp_number ).first() gps_checkin = None created = False if existing_checkin: logger.info(f"[BULK_UPLOAD] 📍 Existing checkin found - ID: {request_id}, CP: {checkpoint.cp_number}, existing_id: {existing_checkin.id}") gps_checkin = existing_checkin else: # 新規チェックインの作成 # 撮影時刻を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 # チェックインデータを作成 gps_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}", ) logger.info(f"[BULK_UPLOAD] ✅ Created checkin - ID: {request_id}, checkin_id: {gps_checkin.id}, CP: {checkpoint.cp_number}, time: {create_at}, points: {gps_checkin.points}") created = True # S3に写真をアップロード logger.info(f"[BULK_UPLOAD] 📤 Uploading photo to S3 - ID: {request_id}, CP: {checkpoint.cp_number}") s3_result = upload_photo_to_s3( uploaded_file, event_code, zekken_number, checkpoint.cp_number, request_id ) checkin_image = None # S3アップロードが成功した場合も失敗した場合もCheckinImagesレコードを作成 checkin_image = create_checkin_image_record( gps_checkin, s3_result['s3_url'], # S3アップロードが失敗した場合はNone s3_result['s3_key'], uploaded_file.name, exif_data, request_id, user ) if s3_result['success']: logger.info(f"[BULK_UPLOAD] ✅ Photo uploaded to S3 and CheckinImages record created - ID: {request_id}") else: logger.warning(f"[BULK_UPLOAD] ⚠️ S3 upload failed but CheckinImages record created with local path - ID: {request_id}, error: {s3_result['error']}") return { 'gps_checkin': gps_checkin, 'checkin_image': checkin_image, 's3_info': s3_result, 'created': created } 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: # ファイルポインタを先頭に戻す（S3アップロード用） uploaded_file.seek(0) # チェックインデータを作成（S3アップロードとCheckinImages登録も含む） checkin_result = create_checkin_from_photo( entry, nearest_checkpoint, exif_data['datetime'], zekken_number, event_code, uploaded_file, exif_data, request_id, request.user ) if checkin_result and checkin_result['gps_checkin']: gps_checkin = checkin_result['gps_checkin'] checkin_image = checkin_result['checkin_image'] s3_info = checkin_result['s3_info'] 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": gps_checkin.points, "checkin_time": gps_checkin.create_at.strftime("%Y-%m-%d %H:%M:%S"), "checkin_id": gps_checkin.id, "was_existing": not checkin_result['created'] }, "s3_info": { "uploaded": s3_info['success'], "s3_url": s3_info['s3_url'], "error": s3_info['error'] }, "checkin_image_info": { "created": checkin_image is not None, "image_id": checkin_image.id if checkin_image else None }, "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)