GarminSync/garminsync/migrate_activities.py

#!/usr/bin/env python3
"""
Migration script to populate new activity fields from Garmin API
"""

import os
import sys
from datetime import datetime
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine, MetaData, Table, text
from sqlalchemy.exc import OperationalError

# Add the parent directory to the path to import garminsync modules
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from garminsync.database import Activity, get_session, init_db
from garminsync.garmin import GarminClient


def add_columns_to_database():
    """Add new columns to the activities table if they don't exist"""
    print("Adding new columns to database...")
    
    # Get database engine
    db_path = os.path.join(os.getenv("DATA_DIR", "data"), "garmin.db")
    engine = create_engine(f"sqlite:///{db_path}")
    
    try:
        # Reflect the existing database schema
        metadata = MetaData()
        metadata.reflect(bind=engine)
        
        # Get the activities table
        activities_table = metadata.tables['activities']
        
        # Check if columns already exist
        existing_columns = [col.name for col in activities_table.columns]
        new_columns = ['activity_type', 'duration', 'distance', 'max_heart_rate', 'avg_power', 'calories']
        
        # Add missing columns
        with engine.connect() as conn:
            for column_name in new_columns:
                if column_name not in existing_columns:
                    print(f"Adding column {column_name}...")
                    if column_name in ['distance', 'avg_power']:
                        conn.execute(text(f"ALTER TABLE activities ADD COLUMN {column_name} REAL"))
                    elif column_name in ['duration', 'max_heart_rate', 'calories']:
                        conn.execute(text(f"ALTER TABLE activities ADD COLUMN {column_name} INTEGER"))
                    else:
                        conn.execute(text(f"ALTER TABLE activities ADD COLUMN {column_name} TEXT"))
                    conn.commit()
                    print(f"Column {column_name} added successfully")
                else:
                    print(f"Column {column_name} already exists")
        
        print("Database schema updated successfully")
        return True
        
    except Exception as e:
        print(f"Failed to update database schema: {e}")
        return False


def migrate_activities():
    """Migrate activities to populate new fields from Garmin API"""
    print("Starting activity migration...")
    
    # First, add columns to database
    if not add_columns_to_database():
        return False
    
    # Initialize Garmin client
    try:
        client = GarminClient()
        print("Garmin client initialized successfully")
    except Exception as e:
        print(f"Failed to initialize Garmin client: {e}")
        # Continue with migration but without Garmin data
        client = None
    
    # Get database session
    session = get_session()
    
    try:
        # Get all activities that need to be updated (those with NULL activity_type)
        activities = session.query(Activity).filter(Activity.activity_type.is_(None)).all()
        print(f"Found {len(activities)} activities to migrate")
        
        # If no activities found, try to get all activities (in case activity_type column was just added)
        if len(activities) == 0:
            activities = session.query(Activity).all()
            print(f"Found {len(activities)} total activities")
        
        updated_count = 0
        error_count = 0
        
        for i, activity in enumerate(activities):
            try:
                print(f"Processing activity {i+1}/{len(activities)} (ID: {activity.activity_id})")
                
                # Fetch detailed activity data from Garmin (if client is available)
                activity_details = None
                if client:
                    activity_details = client.get_activity_details(activity.activity_id)
                
                # Update activity fields if we have details
                if activity_details:
                    # Update activity fields
                    activity.activity_type = activity_details.get('activityType', {}).get('typeKey')
                    
                    # Extract duration in seconds
                    duration = activity_details.get('summaryDTO', {}).get('duration')
                    if duration is not None:
                        activity.duration = int(float(duration))
                    
                    # Extract distance in meters
                    distance = activity_details.get('summaryDTO', {}).get('distance')
                    if distance is not None:
                        activity.distance = float(distance)
                    
                    # Extract max heart rate
                    max_hr = activity_details.get('summaryDTO', {}).get('maxHR')
                    if max_hr is not None:
                        activity.max_heart_rate = int(float(max_hr))
                    
                    # Extract average power
                    avg_power = activity_details.get('summaryDTO', {}).get('avgPower')
                    if avg_power is not None:
                        activity.avg_power = float(avg_power)
                    
                    # Extract calories
                    calories = activity_details.get('summaryDTO', {}).get('calories')
                    if calories is not None:
                        activity.calories = int(float(calories))
                else:
                    # Set default values for activity type if we can't get details
                    activity.activity_type = "Unknown"
                
                # Update last sync timestamp
                activity.last_sync = datetime.now().isoformat()
                
                session.commit()
                updated_count += 1
                
                # Print progress every 10 activities
                if (i + 1) % 10 == 0:
                    print(f"  Progress: {i+1}/{len(activities)} activities processed")
                    
            except Exception as e:
                print(f"  Error processing activity {activity.activity_id}: {e}")
                session.rollback()
                error_count += 1
                continue
        
        print(f"Migration completed. Updated: {updated_count}, Errors: {error_count}")
        return True  # Allow partial success
        
    except Exception as e:
        print(f"Migration failed: {e}")
        return False
    finally:
        session.close()


if __name__ == "__main__":
    success = migrate_activities()
    sys.exit(0 if success else 1)