2026.06.04 frontend építés közben

backend/scripts/cleanup_test_vehicles.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""
+Cleanup script to delete test vehicles from the database.
+
+Deletes vehicles that belong to the test user (tester_pro@profibot.hu)
+OR have status 'draft' OR have license plate starting with "TEST".
+
+Handles foreign key constraints by deleting child records first.
+"""
+
+import asyncio
+import sys
+import os
+
+# Add the backend directory to the path so we can import app modules
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from sqlalchemy import text, delete, select, and_, or_
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+
+from app.core.config import settings
+
+async def cleanup_test_vehicles():
+    """Delete test vehicles and related records."""
+    # Create async engine
+    engine = create_async_engine(settings.DATABASE_URL, echo=False)
+    async_session = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+    
+    deleted_counts = {
+        'asset_events': 0,
+        'asset_assignments': 0,
+        'asset_telemetry': 0,
+        'asset_financials': 0,
+        'asset_costs': 0,
+        'asset_inspections': 0,
+        'asset_reviews': 0,
+        'vehicle_expenses': 0,
+        'vehicle_logbook': 0,
+        'vehicle_ownership_history': 0,
+        'vehicle_transfer_requests': 0,
+        'service_requests': 0,
+        'vehicle_assets': 0
+    }
+    
+    async with async_session() as session:
+        try:
+            # First, find all vehicle asset IDs that match our criteria
+            # We need to join with identity.users and identity.persons to find test user's vehicles
+            query = text("""
+                SELECT va.id
+                FROM vehicle.assets va
+                LEFT JOIN identity.persons p ON va.owner_person_id = p.id
+                LEFT JOIN identity.users u ON p.id = u.person_id
+                WHERE u.email = 'tester_pro@profibot.hu'
+                   OR va.status = 'draft'
+                   OR va.license_plate LIKE 'TEST%'
+            """)
+            
+            result = await session.execute(query)
+            asset_ids = [row[0] for row in result.fetchall()]
+            
+            if not asset_ids:
+                print("No test vehicles found matching criteria.")
+                return deleted_counts
+            
+            print(f"Found {len(asset_ids)} test vehicles to delete.")
+            
+            # Delete from child tables first (order matters due to foreign keys)
+            # List of tables with foreign keys to vehicle.assets.id and their column names
+            tables_to_clean = [
+                ('fleet.asset_assignments', 'asset_id', 'asset_assignments'),
+                ('vehicle.asset_costs', 'asset_id', 'asset_costs'),
+                ('vehicle.asset_events', 'asset_id', 'asset_events'),
+                ('vehicle.asset_financials', 'asset_id', 'asset_financials'),
+                ('vehicle.asset_inspections', 'asset_id', 'asset_inspections'),
+                ('vehicle.asset_reviews', 'asset_id', 'asset_reviews'),
+                ('vehicle.asset_telemetry', 'asset_id', 'asset_telemetry'),
+                ('marketplace.service_requests', 'asset_id', 'service_requests'),
+                ('vehicle.vehicle_expenses', 'vehicle_id', 'vehicle_expenses'),
+                ('vehicle.vehicle_logbook', 'asset_id', 'vehicle_logbook'),
+                ('vehicle.vehicle_ownership_history', 'asset_id', 'vehicle_ownership_history'),
+                ('vehicle.vehicle_transfer_requests', 'asset_id', 'vehicle_transfer_requests'),
+            ]
+            
+            for table, column, key in tables_to_clean:
+                try:
+                    delete_query = text(f"DELETE FROM {table} WHERE {column} = ANY(:asset_ids)")
+                    result = await session.execute(delete_query, {"asset_ids": asset_ids})
+                    deleted_counts[key] = result.rowcount
+                    print(f"Deleted {result.rowcount} records from {table}")
+                except Exception as e:
+                    print(f"Warning: Could not delete from {table}: {e}")
+                    # Continue with other tables
+            
+            # Finally, delete from vehicle.assets
+            delete_assets = text("DELETE FROM vehicle.assets WHERE id = ANY(:asset_ids)")
+            result = await session.execute(delete_assets, {"asset_ids": asset_ids})
+            deleted_counts['vehicle_assets'] = result.rowcount
+            print(f"Deleted {result.rowcount} records from vehicle.assets")
+            
+            # Commit the transaction
+            await session.commit()
+            print("Cleanup completed successfully.")
+            
+        except Exception as e:
+            await session.rollback()
+            print(f"Error during cleanup: {e}")
+            raise
+    
+    await engine.dispose()
+    return deleted_counts
+
+if __name__ == "__main__":
+    print("Starting cleanup of test vehicles...")
+    counts = asyncio.run(cleanup_test_vehicles())
+    print("\nCleanup summary:")
+    for table, count in counts.items():
+        print(f"  {table}: {count}")
+    total = sum(counts.values())
+    print(f"Total records deleted: {total}")