2026.06.04 frontend építés közben

backend/scripts/purge_test_data_simple.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""
+Simplified Ground Zero Database Purge Script
+
+Deletes ALL test users and lets database cascade constraints handle the rest.
+"""
+
+import asyncio
+import sys
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+
+# Import settings
+sys.path.insert(0, '/app')
+from app.core.config import settings
+
+async def purge_test_data_simple():
+    """Simple purge function using cascade delete"""
+    # Create async engine
+    engine = create_async_engine(
+        str(settings.SQLALCHEMY_DATABASE_URI),
+        echo=False,
+        pool_size=5,
+        max_overflow=10,
+    )
+    
+    async_session = sessionmaker(
+        engine, class_=AsyncSession, expire_on_commit=False
+    )
+    
+    async with async_session() as session:
+        try:
+            print("🔍 Starting Ground Zero database purge (simplified)...")
+            print("=" * 60)
+            
+            # 1. First, identify test users to delete
+            test_email_patterns = [
+                '%test%',
+                '%noreply%', 
+                '%profibot%',
+                'tester_pro@profibot.hu',
+                'test@example.com',
+                '%example.com',
+                '%@gmail.com'  # Also delete gmail test users
+            ]
+            
+            # Build WHERE clause for test users
+            where_conditions = []
+            for pattern in test_email_patterns:
+                where_conditions.append(f"email ILIKE '{pattern}'")
+            
+            where_clause = " OR ".join(where_conditions)
+            
+            # 2. Get count of test users
+            count_query = text(f"""
+                SELECT COUNT(*) 
+                FROM identity.users 
+                WHERE {where_clause}
+                AND is_deleted = false
+            """)
+            
+            result = await session.execute(count_query)
+            test_user_count = result.scalar()
+            
+            if test_user_count == 0:
+                print("✅ No test users found to delete.")
+                return
+            
+            # 3. Get list of test users
+            list_query = text(f"""
+                SELECT id, email 
+                FROM identity.users 
+                WHERE {where_clause}
+                AND is_deleted = false
+                LIMIT 20
+            """)
+            
+            result = await session.execute(list_query)
+            test_users = result.fetchall()
+            
+            print(f"📋 Found {test_user_count} test users to delete:")
+            for user in test_users:
+                print(f"   - {user[1]} (ID: {user[0]})")
+            if test_user_count > 20:
+                print(f"   ... and {test_user_count - 20} more")
+            
+            # 4. Delete users (cascade will handle related records)
+            delete_query = text(f"""
+                DELETE FROM identity.users 
+                WHERE {where_clause}
+                AND is_deleted = false
+                RETURNING id, email
+            """)
+            
+            print("\n🗑️  Deleting test users (cascade delete will handle related records)...")
+            result = await session.execute(delete_query)
+            deleted_users = result.fetchall()
+            
+            # 5. Also delete any orphaned persons
+            cleanup_persons_query = text("""
+                DELETE FROM identity.persons 
+                WHERE NOT EXISTS (
+                    SELECT 1 FROM identity.users 
+                    WHERE users.person_id = persons.id
+                )
+                RETURNING id
+            """)
+            
+            result = await session.execute(cleanup_persons_query)
+            orphaned_persons = result.rowcount
+            
+            # Commit transaction
+            await session.commit()
+            
+            print("=" * 60)
+            print("✅ Ground Zero purge completed successfully!")
+            print(f"\n📊 Deletion Summary:")
+            print(f"   Test users deleted: {len(deleted_users)}")
+            print(f"   Orphaned persons cleaned up: {orphaned_persons}")
+            
+            # 6. Verify cleanup
+            verify_query = text(f"""
+                SELECT COUNT(*) 
+                FROM identity.users 
+                WHERE {where_clause}
+                AND is_deleted = false
+            """)
+            
+            result = await session.execute(verify_query)
+            remaining = result.scalar()
+            
+            if remaining == 0:
+                print(f"\n✅ Verification: All test users have been removed.")
+            else:
+                print(f"\n⚠️  Verification: {remaining} test users still remain.")
+            
+            return len(deleted_users)
+            
+        except Exception as e:
+            await session.rollback()
+            print(f"❌ Error during purge: {e}")
+            raise
+
+if __name__ == "__main__":
+    asyncio.run(purge_test_data_simple())