ステップ3：位置情報機能とデータ管理 - DynamoDBとNoSQLデータベース設計

import json
import logging
import boto3
import uuid
from datetime import datetime
from decimal import Decimal
import math
 
# ログ設定
logger = logging.getLogger()
logger.setLevel(logging.INFO)
 
# DynamoDBクライアント
dynamodb = boto3.resource('dynamodb')
checkins_table = dynamodb.Table('checkins-table')
 
def lambda_handler(event, context):
    """
    チェックイン機能のAPIリクエストを処理する関数
    """
    try:
        # リクエスト情報をログに記録
        logger.info(f"受信したイベント: {json.dumps(event)}")
 
        # 認証情報を取得
        request_context = event.get('requestContext', {})
        authorizer = request_context.get('authorizer', {})
        claims = authorizer.get('claims', {})
 
        user_id = claims.get('sub', 'unknown')
        email = claims.get('email', 'unknown')
 
        # HTTPメソッドとパスを取得
        http_method = event.get('httpMethod', 'GET')
        path = event.get('path', '/')
 
        # リクエストボディを取得
        body = {}
        if event.get('body'):
            body = json.loads(event.get('body'))
 
        # パスに応じた処理の分岐
        if path == '/health' and http_method == 'GET':
            # ヘルスチェック用のレスポンス
            return {
                'statusCode': 200,
                'headers': {
                    'Content-Type': 'application/json',
                    'Access-Control-Allow-Origin': '*',
                },
                'body': json.dumps({
                    'message': '認証されたユーザーからのリクエストを受信しました',
                    'user_info': {
                        'user_id': user_id,
                        'email': email
                    },
                    'request_info': {
                        'method': http_method,
                        'path': path
                    },
                    'timestamp': context.aws_request_id
                }, ensure_ascii=False)
            }
        elif path == '/checkin' and http_method == 'POST':
            return create_checkin(user_id, body)
        elif path == '/checkins' and http_method == 'GET':
            return get_checkins(user_id, event.get('queryStringParameters', {}))
        elif path == '/checkins/nearby' and http_method == 'GET':
            return get_nearby_checkins(user_id, event.get('queryStringParameters', {}))
        else:
            return create_error_response(404, 'エンドポイントが見つかりません')
 
    except Exception as e:
        logger.error(f"エラーが発生しました: {str(e)}")
        return create_error_response(500, 'サーバー内部エラーが発生しました', str(e))
 
def create_checkin(user_id, body):
    """チェックイン作成"""
    try:
        checkin_id = str(uuid.uuid4())
        timestamp = body.get('timestamp', datetime.now().isoformat())
        latitude = body.get('latitude', 0)
        longitude = body.get('longitude', 0)
 
        checkin_data = {
            'userId': user_id,
            'timestamp': timestamp,
            'checkInId': checkin_id,
            'latitude': Decimal(str(latitude)),
            'longitude': Decimal(str(longitude)),
            'memo': body.get('memo', ''),
            'createdAt': datetime.now().isoformat()
        }
 
        checkins_table.put_item(Item=checkin_data)
 
        logger.info(f"チェックイン作成成功: userId={user_id}, checkInId={checkin_id}")
 
        return {
            'statusCode': 201,
            'headers': {
                'Content-Type': 'application/json',
                'Access-Control-Allow-Origin': '*',
            },
            'body': json.dumps({
                'message': 'チェックインを作成しました',
                'checkInId': checkin_id,
                'userId': user_id,
                'latitude': float(latitude),
                'longitude': float(longitude),
                'timestamp': timestamp
            }, ensure_ascii=False)
        }
 
    except Exception as e:
        logger.error(f"チェックイン作成エラー: {str(e)}")
        return create_error_response(500, 'チェックインの作成に失敗しました', str(e))
 
def get_checkins(user_id, query_params):
    """チェックイン履歴取得"""
    try:
        limit = int(query_params.get('limit', 50))
 
        response = checkins_table.query(
            KeyConditionExpression='userId = :userId',
            ExpressionAttributeValues={':userId': user_id},
            ScanIndexForward=False,  # 新しい順
            Limit=limit
        )
 
        items = response.get('Items', [])
 
        logger.info(f"チェックイン取得成功: userId={user_id}, count={len(items)}")
 
        return {
            'statusCode': 200,
            'headers': {
                'Content-Type': 'application/json',
                'Access-Control-Allow-Origin': '*',
            },
            'body': json.dumps({
                'items': convert_decimal_to_float(items),
                'count': len(items)
            }, ensure_ascii=False)
        }
 
    except Exception as e:
        logger.error(f"チェックイン取得エラー: {str(e)}")
        return create_error_response(500, 'チェックインの取得に失敗しました', str(e))
 
def get_nearby_checkins(user_id, query_params):
    """近隣チェックイン検索"""
    try:
        center_lat = float(query_params.get('latitude', 0))
        center_lon = float(query_params.get('longitude', 0))
        radius_km = float(query_params.get('radius', 5))
 
        # 全チェックインをスキャン（小規模データ向け）
        response = checkins_table.scan()
        all_checkins = response.get('Items', [])
 
        # 距離計算して範囲内のチェックインをフィルタ
        nearby_checkins = []
        for checkin in all_checkins:
            lat = float(checkin.get('latitude', 0))
            lon = float(checkin.get('longitude', 0))
            distance = calculate_distance(center_lat, center_lon, lat, lon)
 
            if distance <= radius_km:
                checkin_dict = convert_decimal_to_float(checkin)
                checkin_dict['distance'] = round(distance, 2)
                nearby_checkins.append(checkin_dict)
 
        # 距離順にソート
        nearby_checkins.sort(key=lambda x: x['distance'])
 
        logger.info(f"近隣チェックイン検索成功: count={len(nearby_checkins)}")
 
        return {
            'statusCode': 200,
            'headers': {
                'Content-Type': 'application/json',
                'Access-Control-Allow-Origin': '*',
            },
            'body': json.dumps({
                'items': nearby_checkins,
                'count': len(nearby_checkins),
                'center': {'latitude': center_lat, 'longitude': center_lon},
                'radiusKm': radius_km
            }, ensure_ascii=False)
        }
 
    except Exception as e:
        logger.error(f"近隣検索エラー: {str(e)}")
        return create_error_response(500, '近隣チェックインの検索に失敗しました', str(e))
 
def calculate_distance(lat1, lon1, lat2, lon2):
    """2点間の距離を計算（Haversine公式）"""
    # 地球の半径（km）
    R = 6371.0
 
    # ラジアンに変換
    lat1_rad = math.radians(lat1)
    lon1_rad = math.radians(lon1)
    lat2_rad = math.radians(lat2)
    lon2_rad = math.radians(lon2)
 
    # 差分
    dlat = lat2_rad - lat1_rad
    dlon = lon2_rad - lon1_rad
 
    # Haversine公式
    a = math.sin(dlat / 2)**2 + math.cos(lat1_rad) * math.cos(lat2_rad) * math.sin(dlon / 2)**2
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
 
    distance = R * c
    return distance
 
def create_success_response(data):
    """成功レスポンスの生成"""
    return {
        'statusCode': 200,
        'headers': {
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*',
            'Access-Control-Allow-Methods': 'GET,POST,PUT,DELETE,OPTIONS',
            'Access-Control-Allow-Headers': 'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token'
        },
        'body': json.dumps(data, ensure_ascii=False)
    }
 
def create_error_response(status_code, message, detail=None):
    """エラーレスポンスの生成"""
    error_data = {'error': message}
    if detail:
        error_data['detail'] = detail
 
    return {
        'statusCode': status_code,
        'headers': {
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*'
        },
        'body': json.dumps(error_data, ensure_ascii=False)
    }
 
def convert_decimal_to_float(obj):
    """DynamoDBのDecimal型をfloatに変換"""
    if isinstance(obj, dict):
        return {k: convert_decimal_to_float(v) for k, v in obj.items()}
    elif isinstance(obj, list):
        return [convert_decimal_to_float(v) for v in obj]
    elif isinstance(obj, Decimal):
        return float(obj)
    else:
        return obj

# 環境変数の設定
export API_URL="https://xxxxxxxxxx.execute-api.us-east-1.amazonaws.com/prod"
export ID_TOKEN=$(aws cognito-idp initiate-auth \
  --client-id ${CLIENT_ID} \
  --auth-flow USER_PASSWORD_AUTH \
  --auth-parameters USERNAME=testuser@example.com,PASSWORD=Test1234! \
  --region us-east-1 \
  --output json | jq -r '.AuthenticationResult.IdToken')
 
# チェックインの作成
curl -X POST "${API_URL}/checkin" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${ID_TOKEN}" \
  -d '{
    "latitude": 35.6812,
    "longitude": 139.7671,
    "memo": "東京駅でチェックイン",
    "timestamp": "2025-10-31T10:30:00Z"
  }'

{
  "message": "チェックインを作成しました",
  "checkInId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "userId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "latitude": 35.6812,
  "longitude": 139.7671,
  "timestamp": "2025-10-31T10:30:00Z"
}

# チェックイン履歴の取得
curl -X GET "${API_URL}/checkins?limit=10" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${ID_TOKEN}"

{
  "items": [
    {
      "checkInId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
      "userId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
      "latitude": 35.6812,
      "longitude": 139.7671,
      "memo": "東京駅でチェックイン",
      "timestamp": "2025-10-31T10:30:00Z",
      "createdAt": "2025-10-31T10:30:00Z"
    }
  ],
  "count": 1
}

# 渋谷でチェックイン
curl -X POST "${API_URL}/checkin" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${ID_TOKEN}" \
  -d '{
    "latitude": 35.6595,
    "longitude": 139.7004,
    "memo": "渋谷スクランブル交差点",
    "timestamp": "2025-10-31T11:00:00Z"
  }'
 
# 新宿でチェックイン
curl -X POST "${API_URL}/checkin" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${ID_TOKEN}" \
  -d '{
    "latitude": 35.6896,
    "longitude": 139.7006,
    "memo": "新宿駅",
    "timestamp": "2025-10-31T11:30:00Z"
  }'
 
# 大阪（梅田）でチェックイン
curl -X POST "${API_URL}/checkin" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${ID_TOKEN}" \
  -d '{
    "latitude": 34.7024,
    "longitude": 135.4959,
    "memo": "大阪駅",
    "timestamp": "2025-10-31T12:00:00Z"
  }'

# 東京駅周辺（半径5km）のチェックインを検索
curl -X GET "${API_URL}/checkins/nearby?latitude=35.6812&longitude=139.7671&radius=5" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${ID_TOKEN}"

{
  "items": [
    {
      "checkInId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
      "latitude": 35.6812,
      "longitude": 139.7671,
      "memo": "東京駅でチェックイン",
      "distance": 0.0
    },
    {
      "checkInId": "yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy",
      "latitude": 35.6896,
      "longitude": 139.7006,
      "memo": "新宿駅",
      "distance": 2.5
    }
  ],
  "count": 2,
  "center": {
    "latitude": 35.6812,
    "longitude": 139.7671
  },
  "radiusKm": 5
}

# 最新のチェックインから取得（timestampでソート）
curl -X GET "${API_URL}/checkins?sortBy=timestamp&order=desc&limit=5" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${ID_TOKEN}"

{
  "items": [
    {
      "checkInId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
      "timestamp": "2025-10-31T12:00:00Z",
      "memo": "大阪駅"
    },
    {
      "checkInId": "yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy",
      "timestamp": "2025-10-31T11:30:00Z",
      "memo": "新宿駅"
    },
    {
      "checkInId": "zzzzzzzz-zzzz-zzzz-zzzz-zzzzzzzzzzzz",
      "timestamp": "2025-10-31T11:00:00Z",
      "memo": "渋谷スクランブル交差点"
    }
  ],
  "count": 3
}

START RequestId: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
[INFO] チェックイン作成リクエスト: userId=xxxxxxxx, lat=35.6812, lon=139.7671
[INFO] DynamoDB PutItem 成功
END RequestId: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
REPORT RequestId: xxxxxxxx Duration: 120.00 ms Billed Duration: 121 ms Memory Size: 256 MB Max Memory Used: 75 MB