2026.03.29 20:00 Gitea_manager javítás előtt

backend/app/scripts/move_tables.py.old

@@ -1,58 +0,0 @@
-#!/usr/bin/env python3
-"""
-Move tables from system schema to gamification schema.
-"""
-import asyncio
-from sqlalchemy.ext.asyncio import create_async_engine
-from sqlalchemy import text
-
-async def move_tables():
-    # Use the same DATABASE_URL as sync_engine
-    from app.core.config import settings
-    engine = create_async_engine(str(settings.SQLALCHEMY_DATABASE_URI))
-    
-    async with engine.begin() as conn:
-        # Check if tables exist in system schema
-        result = await conn.execute(text("""
-            SELECT table_schema, table_name 
-            FROM information_schema.tables 
-            WHERE table_name IN ('competitions', 'user_scores') 
-            ORDER BY table_schema;
-        """))
-        rows = result.fetchall()
-        print("Current tables:")
-        for row in rows:
-            print(f"  {row.table_schema}.{row.table_name}")
-        
-        # Move competitions
-        print("\nMoving system.competitions to gamification.competitions...")
-        try:
-            await conn.execute(text('ALTER TABLE system.competitions SET SCHEMA gamification;'))
-            print("  OK")
-        except Exception as e:
-            print(f"  Error: {e}")
-        
-        # Move user_scores
-        print("Moving system.user_scores to gamification.user_scores...")
-        try:
-            await conn.execute(text('ALTER TABLE system.user_scores SET SCHEMA gamification;'))
-            print("  OK")
-        except Exception as e:
-            print(f"  Error: {e}")
-        
-        # Verify
-        result = await conn.execute(text("""
-            SELECT table_schema, table_name 
-            FROM information_schema.tables 
-            WHERE table_name IN ('competitions', 'user_scores') 
-            ORDER BY table_schema;
-        """))
-        rows = result.fetchall()
-        print("\nAfter moving:")
-        for row in rows:
-            print(f"  {row.table_schema}.{row.table_name}")
-    
-    await engine.dispose()
-
-if __name__ == "__main__":
-    asyncio.run(move_tables())

backend/app/scripts/rename_deprecated.py.old

@@ -1,53 +0,0 @@
-#!/usr/bin/env python3
-"""
-Rename tables in system schema to deprecated to avoid extra detection.
-"""
-import asyncio
-from sqlalchemy.ext.asyncio import create_async_engine
-from sqlalchemy import text
-
-async def rename():
-    from app.core.config import settings
-    engine = create_async_engine(str(settings.SQLALCHEMY_DATABASE_URI))
-    
-    async with engine.begin() as conn:
-        # Check if tables exist
-        result = await conn.execute(text("""
-            SELECT table_schema, table_name 
-            FROM information_schema.tables 
-            WHERE table_schema = 'system' AND table_name IN ('competitions', 'user_scores');
-        """))
-        rows = result.fetchall()
-        print("Tables to rename:")
-        for row in rows:
-            print(f"  {row.table_schema}.{row.table_name}")
-        
-        # Rename competitions
-        try:
-            await conn.execute(text('ALTER TABLE system.competitions RENAME TO competitions_deprecated;'))
-            print("Renamed system.competitions -> system.competitions_deprecated")
-        except Exception as e:
-            print(f"Error renaming competitions: {e}")
-        
-        # Rename user_scores
-        try:
-            await conn.execute(text('ALTER TABLE system.user_scores RENAME TO user_scores_deprecated;'))
-            print("Renamed system.user_scores -> system.user_scores_deprecated")
-        except Exception as e:
-            print(f"Error renaming user_scores: {e}")
-        
-        # Verify
-        result = await conn.execute(text("""
-            SELECT table_schema, table_name 
-            FROM information_schema.tables 
-            WHERE table_schema = 'system' AND table_name LIKE '%deprecated';
-        """))
-        rows = result.fetchall()
-        print("\nAfter rename:")
-        for row in rows:
-            print(f"  {row.table_schema}.{row.table_name}")
-    
-    await engine.dispose()
-
-if __name__ == "__main__":
-    asyncio.run(rename())

backend/app/scripts/seed_completion_weights.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""
+Seed script for system.data_completion_weights table.
+Populates default weights for vehicle asset completion percentage calculation.
+"""
+import asyncio
+import logging
+from sqlalchemy import select
+from app.database import AsyncSessionLocal
+from app.models.system.system import SystemDataCompletionWeight
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s]: %(message)s')
+logger = logging.getLogger("Seed-Completion-Weights")
+
+async def seed_completion_weights():
+    """Seed default data completion weights for entity_type='asset'."""
+    async with AsyncSessionLocal() as db:
+        # Check if weights already exist for entity_type='asset'
+        stmt = select(SystemDataCompletionWeight).where(
+            SystemDataCompletionWeight.entity_type == "asset"
+        )
+        result = await db.execute(stmt)
+        existing = result.scalars().all()
+        
+        if existing:
+            logger.info(f"Found {len(existing)} existing weights for entity_type='asset'. Skipping seed.")
+            return
+        
+        # Default weights for vehicle assets (total: 100%)
+        weights = [
+            {
+                "entity_type": "asset",
+                "field_name": "license_plate",
+                "weight_percent": 20,
+                "is_mandatory": False,
+                "is_active": True,
+                "is_read": False,
+                "description": "Rendszám - alapvető azonosító"
+            },
+            {
+                "entity_type": "asset",
+                "field_name": "make",
+                "weight_percent": 15,
+                "is_mandatory": False,
+                "is_active": True,
+                "is_read": False,
+                "description": "Gyártó (márka)"
+            },
+            {
+                "entity_type": "asset",
+                "field_name": "model",
+                "weight_percent": 15,
+                "is_mandatory": False,
+                "is_active": True,
+                "is_read": False,
+                "description": "Modell"
+            },
+            {
+                "entity_type": "asset",
+                "field_name": "vin",
+                "weight_percent": 30,
+                "is_mandatory": False,
+                "is_active": True,
+                "is_read": False,
+                "description": "Alvázszám (VIN) - egyedi azonosító"
+            },
+            {
+                "entity_type": "asset",
+                "field_name": "year_of_manufacture",
+                "weight_percent": 20,
+                "is_mandatory": False,
+                "is_active": True,
+                "is_read": False,
+                "description": "Gyártási év"
+            }
+        ]
+        
+        # Insert weights
+        for weight_data in weights:
+            weight = SystemDataCompletionWeight(**weight_data)
+            db.add(weight)
+        
+        await db.commit()
+        logger.info(f"Successfully seeded {len(weights)} completion weights for entity_type='asset'")
+        
+        # Log the total percentage
+        total = sum(w["weight_percent"] for w in weights)
+        logger.info(f"Total weight percentage: {total}%")
+
+async def main():
+    """Main entry point."""
+    try:
+        await seed_completion_weights()
+    except Exception as e:
+        logger.error(f"Failed to seed completion weights: {e}", exc_info=True)
+        raise
+
+if __name__ == "__main__":
+    asyncio.run(main())

backend/app/scripts/sync_engine1.0.py.old

@@ -1,170 +0,0 @@
-# /opt/docker/dev/service_finder/backend/app/scripts/sync_engine.py
-#!/usr/bin/env python3
-"""
-Universal Schema Synchronizer
-
-Dynamically imports all SQLAlchemy models from app.models, compares them with the live database,
-and creates missing tables/columns without dropping anything.
-
-Safety First:
-- NEVER drops tables or columns.
-- Prints planned SQL before execution.
-- Requires confirmation for destructive operations (none in this script).
-"""
-
-import asyncio
-import importlib
-import os
-import sys
-from pathlib import Path
-from sqlalchemy.ext.asyncio import create_async_engine
-from sqlalchemy import inspect, text
-from sqlalchemy.schema import CreateTable, AddConstraint
-from sqlalchemy.sql.ddl import CreateColumn
-
-# Add backend to path
-sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-from app.database import Base
-from app.core.config import settings
-
-def dynamic_import_models():
-    """
-    Dynamically import all .py files in app.models directory to ensure Base.metadata is populated.
-    """
-    models_dir = Path(__file__).parent.parent / "models"
-    imported = []
-    
-    for py_file in models_dir.glob("*.py"):
-        if py_file.name == "__init__.py":
-            continue
-        module_name = f"app.models.{py_file.stem}"
-        try:
-            module = importlib.import_module(module_name)
-            imported.append(module_name)
-            print(f"✅ Imported {module_name}")
-        except Exception as e:
-            print(f"⚠️  Could not import {module_name}: {e}")
-    
-    # Also ensure the __init__ is loaded (it imports many models manually)
-    import app.models
-    print(f"📦 Total tables in Base.metadata: {len(Base.metadata.tables)}")
-    return imported
-
-async def compare_and_repair():
-    """
-    Compare SQLAlchemy metadata with live database and create missing tables/columns.
-    """
-    print("🔗 Connecting to database...")
-    engine = create_async_engine(str(settings.SQLALCHEMY_DATABASE_URI))
-    
-    def get_diff_and_repair(connection):
-        inspector = inspect(connection)
-        
-        # Get all schemas from models
-        expected_schemas = sorted({t.schema for t in Base.metadata.sorted_tables if t.schema})
-        print(f"📋 Expected schemas: {expected_schemas}")
-        
-        # Ensure enum types exist in marketplace schema
-        if 'marketplace' in expected_schemas:
-            print("\n🔧 Ensuring enum types in marketplace schema...")
-            # moderation_status enum
-            connection.execute(text("""
-                DO $$
-                BEGIN
-                    IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'moderation_status' AND typnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'marketplace')) THEN
-                        CREATE TYPE marketplace.moderation_status AS ENUM ('pending', 'approved', 'rejected');
-                    END IF;
-                END $$;
-            """))
-            # source_type enum
-            connection.execute(text("""
-                DO $$
-                BEGIN
-                    IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'source_type' AND typnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'marketplace')) THEN
-                        CREATE TYPE marketplace.source_type AS ENUM ('manual', 'ocr', 'import');
-                    END IF;
-                END $$;
-            """))
-            print("✅ Enum types ensured.")
-        
-        for schema in expected_schemas:
-            print(f"\n--- 🔍 Checking schema '{schema}' ---")
-            
-            # Check if schema exists
-            db_schemas = inspector.get_schema_names()
-            if schema not in db_schemas:
-                print(f"❌ Schema '{schema}' missing. Creating...")
-                connection.execute(text(f'CREATE SCHEMA IF NOT EXISTS "{schema}"'))
-                print(f"✅ Schema '{schema}' created.")
-            
-            # Get tables in this schema from models
-            model_tables = [t for t in Base.metadata.sorted_tables if t.schema == schema]
-            db_tables = inspector.get_table_names(schema=schema)
-            
-            for table in model_tables:
-                if table.name not in db_tables:
-                    print(f"❌ Missing table: {schema}.{table.name}")
-                    # Generate CREATE TABLE statement
-                    create_stmt = CreateTable(table)
-                    # Print SQL for debugging
-                    sql_str = str(create_stmt.compile(bind=engine))
-                    print(f"   SQL: {sql_str}")
-                    connection.execute(create_stmt)
-                    print(f"✅ Table {schema}.{table.name} created.")
-                else:
-                    # Check columns
-                    db_columns = {c['name']: c for c in inspector.get_columns(table.name, schema=schema)}
-                    model_columns = table.columns
-                    
-                    missing_cols = []
-                    for col in model_columns:
-                        if col.name not in db_columns:
-                            missing_cols.append(col)
-                    
-                    if missing_cols:
-                        print(f"⚠️  Table {schema}.{table.name} missing columns: {[c.name for c in missing_cols]}")
-                        for col in missing_cols:
-                            # Generate ADD COLUMN statement
-                            col_type = col.type.compile(dialect=engine.dialect)
-                            sql = f'ALTER TABLE "{schema}"."{table.name}" ADD COLUMN "{col.name}" {col_type}'
-                            if col.nullable is False:
-                                sql += " NOT NULL"
-                            if col.default is not None:
-                                # Handle default values (simplistic)
-                                sql += f" DEFAULT {col.default.arg}"
-                            print(f"   SQL: {sql}")
-                            connection.execute(text(sql))
-                            print(f"✅ Column {col.name} added.")
-                    else:
-                        print(f"✅ Table {schema}.{table.name} is up‑to‑date.")
-        
-        print("\n--- ✅ Schema synchronization complete. ---")
-    
-    async with engine.begin() as conn:
-        await conn.run_sync(get_diff_and_repair)
-    
-    await engine.dispose()
-
-async def main():
-    print("🚀 Universal Schema Synchronizer")
-    print("=" * 50)
-    
-    # Step 1: Dynamic import
-    print("\n📥 Step 1: Dynamically importing all models...")
-    dynamic_import_models()
-    
-    # Step 2: Compare and repair
-    print("\n🔧 Step 2: Comparing with database and repairing...")
-    await compare_and_repair()
-    
-    # Step 3: Final verification
-    print("\n📊 Step 3: Final verification...")
-    # Run compare_schema.py logic to confirm everything is green
-    from app.tests_internal.diagnostics.compare_schema import compare
-    await compare()
-    
-    print("\n✨ Synchronization finished successfully!")
-
-if __name__ == "__main__":
-    asyncio.run(main())

backend/app/scripts/unified_db_sync_1.0.py.old

@@ -1,232 +0,0 @@
-#!/usr/bin/env python3
-"""
-Unified Database Synchronizer with Deep Constraint & Index Support
-
-Dynamically imports all SQLAlchemy models, compares metadata with live database,
-and creates missing tables, columns, unique constraints, and indexes.
-
-Safety First:
-- NEVER drops tables, columns, constraints, or indexes.
-- Prints planned SQL before execution.
-- Requires confirmation for destructive operations (none in this script).
-"""
-
-import asyncio
-import importlib
-import os
-import sys
-from pathlib import Path
-from sqlalchemy.ext.asyncio import create_async_engine
-from sqlalchemy import inspect, text, UniqueConstraint, Index
-from sqlalchemy.schema import CreateTable, AddConstraint, CreateIndex
-from sqlalchemy.sql.ddl import CreateColumn
-
-# Add backend to path
-sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-from app.database import Base
-from app.core.config import settings
-
-def dynamic_import_models():
-    """
-    Dynamically import all .py files in app.models directory to ensure Base.metadata is populated.
-    """
-    models_dir = Path(__file__).parent.parent / "models"
-    imported = []
-    
-    for py_file in models_dir.glob("*.py"):
-        if py_file.name == "__init__.py":
-            continue
-        module_name = f"app.models.{py_file.stem}"
-        try:
-            module = importlib.import_module(module_name)
-            imported.append(module_name)
-            print(f"✅ Imported {module_name}")
-        except Exception as e:
-            print(f"⚠️  Could not import {module_name}: {e}")
-    
-    # Also ensure the __init__ is loaded (it imports many models manually)
-    import app.models
-    print(f"📦 Total tables in Base.metadata: {len(Base.metadata.tables)}")
-    return imported
-
-async def compare_and_repair(apply: bool = False):
-    """
-    Compare SQLAlchemy metadata with live database and create missing
-    tables, columns, unique constraints, and indexes.
-    
-    If apply is False, only prints SQL statements without executing.
-    """
-    print("🔗 Connecting to database...")
-    engine = create_async_engine(str(settings.SQLALCHEMY_DATABASE_URI))
-    
-    def get_diff_and_repair(connection):
-        inspector = inspect(connection)
-        
-        # Get all schemas from models
-        expected_schemas = sorted({t.schema for t in Base.metadata.sorted_tables if t.schema})
-        print(f"📋 Expected schemas: {expected_schemas}")
-        
-        # Ensure enum types exist in marketplace schema
-        if 'marketplace' in expected_schemas:
-            print("\n🔧 Ensuring enum types in marketplace schema...")
-            # moderation_status enum
-            connection.execute(text("""
-                DO $$
-                BEGIN
-                    IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'moderation_status' AND typnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'marketplace')) THEN
-                        CREATE TYPE marketplace.moderation_status AS ENUM ('pending', 'approved', 'rejected');
-                    END IF;
-                END $$;
-            """))
-            # source_type enum
-            connection.execute(text("""
-                DO $$
-                BEGIN
-                    IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'source_type' AND typnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'marketplace')) THEN
-                        CREATE TYPE marketplace.source_type AS ENUM ('manual', 'ocr', 'import');
-                    END IF;
-                END $$;
-            """))
-            print("✅ Enum types ensured.")
-        
-        for schema in expected_schemas:
-            print(f"\n--- 🔍 Checking schema '{schema}' ---")
-            
-            # Check if schema exists
-            db_schemas = inspector.get_schema_names()
-            if schema not in db_schemas:
-                print(f"❌ Schema '{schema}' missing. Creating...")
-                if apply:
-                    connection.execute(text(f'CREATE SCHEMA IF NOT EXISTS "{schema}"'))
-                    print(f"✅ Schema '{schema}' created.")
-                else:
-                    print(f"   SQL: CREATE SCHEMA IF NOT EXISTS \"{schema}\"")
-            
-            # Get tables in this schema from models
-            model_tables = [t for t in Base.metadata.sorted_tables if t.schema == schema]
-            db_tables = inspector.get_table_names(schema=schema)
-            
-            for table in model_tables:
-                if table.name not in db_tables:
-                    print(f"❌ Missing table: {schema}.{table.name}")
-                    # Generate CREATE TABLE statement
-                    create_stmt = CreateTable(table)
-                    sql_str = str(create_stmt.compile(bind=engine))
-                    print(f"   SQL: {sql_str}")
-                    if apply:
-                        connection.execute(create_stmt)
-                        print(f"✅ Table {schema}.{table.name} created.")
-                    continue
-                
-                # Check columns
-                db_columns = {c['name']: c for c in inspector.get_columns(table.name, schema=schema)}
-                model_columns = table.columns
-                
-                missing_cols = []
-                for col in model_columns:
-                    if col.name not in db_columns:
-                        missing_cols.append(col)
-                
-                if missing_cols:
-                    print(f"⚠️  Table {schema}.{table.name} missing columns: {[c.name for c in missing_cols]}")
-                    for col in missing_cols:
-                        col_type = col.type.compile(dialect=engine.dialect)
-                        sql = f'ALTER TABLE "{schema}"."{table.name}" ADD COLUMN "{col.name}" {col_type}'
-                        if col.nullable is False:
-                            sql += " NOT NULL"
-                        if col.default is not None:
-                            sql += f" DEFAULT {col.default.arg}"
-                        print(f"   SQL: {sql}")
-                        if apply:
-                            connection.execute(text(sql))
-                            print(f"✅ Column {col.name} added.")
-                else:
-                    print(f"✅ Table {schema}.{table.name} columns are up‑to‑date.")
-                
-                # Check Unique Constraints
-                db_unique_constraints = inspector.get_unique_constraints(table.name, schema=schema)
-                # Map by column names (since constraint names may differ)
-                db_unique_map = {}
-                for uc in db_unique_constraints:
-                    key = tuple(sorted(uc['column_names']))
-                    db_unique_map[key] = uc['name']
-                
-                # Find unique constraints defined in model
-                model_unique_constraints = [c for c in table.constraints if isinstance(c, UniqueConstraint)]
-                for uc in model_unique_constraints:
-                    uc_columns = tuple(sorted([col.name for col in uc.columns]))
-                    if uc_columns not in db_unique_map:
-                        # Constraint missing
-                        constraint_name = uc.name or f"uq_{table.name}_{'_'.join(uc_columns)}"
-                        columns_sql = ', '.join([f'"{col}"' for col in uc_columns])
-                        sql = f'ALTER TABLE "{schema}"."{table.name}" ADD CONSTRAINT "{constraint_name}" UNIQUE ({columns_sql})'
-                        print(f"⚠️  Missing unique constraint on {schema}.{table.name} columns {uc_columns}")
-                        print(f"   SQL: {sql}")
-                        if apply:
-                            connection.execute(text(sql))
-                            print(f"✅ Unique constraint {constraint_name} added.")
-                    else:
-                        print(f"✅ Unique constraint on {uc_columns} exists.")
-                
-                # Check Indexes
-                db_indexes = inspector.get_indexes(table.name, schema=schema)
-                db_index_map = {}
-                for idx in db_indexes:
-                    key = tuple(sorted(idx['column_names']))
-                    db_index_map[key] = idx['name']
-                
-                # Find indexes defined in model (Index objects)
-                model_indexes = [idx for idx in table.indexes]
-                for idx in model_indexes:
-                    idx_columns = tuple(sorted([col.name for col in idx.columns]))
-                    if idx_columns not in db_index_map:
-                        # Index missing
-                        index_name = idx.name or f"idx_{table.name}_{'_'.join(idx_columns)}"
-                        columns_sql = ', '.join([f'"{col}"' for col in idx_columns])
-                        unique_sql = "UNIQUE " if idx.unique else ""
-                        sql = f'CREATE {unique_sql}INDEX "{index_name}" ON "{schema}"."{table.name}" ({columns_sql})'
-                        print(f"⚠️  Missing index on {schema}.{table.name} columns {idx_columns}")
-                        print(f"   SQL: {sql}")
-                        if apply:
-                            connection.execute(text(sql))
-                            print(f"✅ Index {index_name} added.")
-                    else:
-                        print(f"✅ Index on {idx_columns} exists.")
-        
-        print("\n--- ✅ Schema synchronization complete. ---")
-    
-    async with engine.begin() as conn:
-        await conn.run_sync(get_diff_and_repair)
-    
-    await engine.dispose()
-
-async def main():
-    import argparse
-    parser = argparse.ArgumentParser(description="Unified Database Synchronizer")
-    parser.add_argument('--apply', action='store_true', help='Apply changes to database (otherwise dry‑run)')
-    args = parser.parse_args()
-    
-    print("🚀 Unified Database Synchronizer")
-    print("=" * 50)
-    
-    # Step 1: Dynamic import
-    print("\n📥 Step 1: Dynamically importing all models...")
-    dynamic_import_models()
-    
-    # Step 2: Compare and repair
-    print("\n🔧 Step 2: Comparing with database and repairing...")
-    await compare_and_repair(apply=args.apply)
-    
-    # Step 3: Final verification
-    print("\n📊 Step 3: Final verification...")
-    try:
-        from app.tests_internal.diagnostics.compare_schema import compare
-        await compare()
-    except ImportError:
-        print("⚠️  compare_schema module not found, skipping verification.")
-    
-    print("\n✨ Synchronization finished successfully!")
-
-if __name__ == "__main__":
-    asyncio.run(main())