861 lines
39 KiB
Python
861 lines
39 KiB
Python
"""
|
||
写真一括アップロード・通過履歴校正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)
|