STABLE: Final schema sync, optimized gitignore

backend/app/scripts/link_catalog_to_mdm.py

@@ -1,78 +1,63 @@
+# /opt/docker/dev/service_finder/backend/app/scripts/link_catalog_to_mdm.py
 import asyncio
-from sqlalchemy import select, update, func
+from sqlalchemy import select, update
 from app.db.session import SessionLocal
 from app.models.asset import AssetCatalog
 from app.models.vehicle_definitions import VehicleModelDefinition, VehicleType
 
 async def link_catalog_to_mdm():
+    """ Összefűzi a technikai katalógust a központi Master Definíciókkal. """
     async with SessionLocal() as db:
         try:
-            print("🔍 Meglévő variánsok elemzése...")
+            print("🔍 Master-Híd építése indul...")
             
-            # 1. Lekérjük a típusokat a gyors kereséshez
+            # 1. Típusok betöltése
             type_res = await db.execute(select(VehicleType))
             types = {t.code: t.id for t in type_res.scalars().all()}
 
-            # 2. Kigyűjtjük az egyedi márkákat és modelleket a katalógusból
-            # Itt csoportosítunk, hogy ne legyen duplikáció
-            stmt = select(
-                AssetCatalog.make, 
-                AssetCatalog.model, 
-                AssetCatalog.vehicle_class
-            ).distinct()
-            
+            # 2. Egyedi variánsok lekérése
+            stmt = select(AssetCatalog.make, AssetCatalog.model, AssetCatalog.vehicle_class).distinct()
             raw_data = await db.execute(stmt)
             unique_models = raw_data.all()
-            
-            print(f"📊 Találtunk {len(unique_models)} egyedi modellt. Összefésülés indul...")
 
             linked_count = 0
             for make, model, v_class in unique_models:
-                # Meghatározzuk a típus ID-t (alapértelmezett: car)
                 t_code = v_class if v_class in types else "car"
                 t_id = types.get(t_code)
 
-                # Keressük, létezik-e már ilyen Master rekord
-                # A technical_code-ot itt ideiglenesen a modell nevével töltjük, 
-                # amíg a robot/AI nem pontosítja
+                # Master rekord keresése vagy létrehozása
                 master_stmt = select(VehicleModelDefinition).where(
                     VehicleModelDefinition.make == make,
                     VehicleModelDefinition.marketing_name == model
                 )
-                master_res = await db.execute(master_stmt)
-                master = master_res.scalar_one_or_none()
+                master = (await db.execute(master_stmt)).scalar_one_or_none()
 
                 if not master:
                     master = VehicleModelDefinition(
                         make=make,
-                        technical_code=model, # Ideiglenes
+                        technical_code=model.replace(" ", "-").lower(),
                         marketing_name=model,
                         vehicle_type=t_code,
                         vehicle_type_id=t_id,
                         status="unverified",
-                        source="initial_linking"
+                        source="linking_process"
                     )
                     db.add(master)
-                    await db.flush() # Hogy megkapjuk az ID-t
+                    await db.flush()
 
-                # 3. Összekötjük az összes variánst ezzel a Master rekorddal
-                update_stmt = update(AssetCatalog).where(
-                    AssetCatalog.make == make,
-                    AssetCatalog.model == model
-                ).values(master_definition_id=master.id)
-                
-                await db.execute(update_stmt)
+                # Összekötés
+                await db.execute(
+                    update(AssetCatalog)
+                    .where(AssetCatalog.make == make, AssetCatalog.model == model)
+                    .values(master_definition_id=master.id)
+                )
                 linked_count += 1
-                
-                if linked_count % 100 == 0:
-                    print(f"⏳ Feldolgozva: {linked_count} modell...")
 
             await db.commit()
-            print(f"✅ Kész! {linked_count} Master rekord létrehozva és összekötve.")
-
+            print(f"✅ Sikeresen összekötve: {linked_count} modell.")
         except Exception as e:
             await db.rollback()
-            print(f"❌ Hiba az összefésülésnél: {e}")
+            print(f"❌ Hiba: {e}")
 
 if __name__ == "__main__":
     asyncio.run(link_catalog_to_mdm())

backend/app/scripts/morning_report.py

@@ -1,13 +1,14 @@
+# /opt/docker/dev/service_finder/backend/app/scripts/morning_report.py
 import asyncio
-from sqlalchemy import select, func
+from sqlalchemy import select
 from app.db.session import SessionLocal
 from app.models.audit import ProcessLog
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 
 async def generate_morning_report():
+    """ Összesíti a háttérfolyamatok (robotok) elmúlt 24 órás teljesítményét. """
     async with SessionLocal() as db:
-        # Az elmúlt 24 óra logjai
-        yesterday = datetime.now() - timedelta(days=1)
+        yesterday = datetime.now(timezone.utc) - timedelta(days=1)
         stmt = select(ProcessLog).where(ProcessLog.start_time >= yesterday)
         res = await db.execute(stmt)
         logs = res.scalars().all()
@@ -15,27 +16,19 @@ async def generate_morning_report():
         report = f"📊 REGGELI ROBOT JELENTÉS - {datetime.now().date()}\n"
         report += "="*40 + "\n"
 
-        total_proc = 0
-        total_fail = 0
-        cleaned_list = []
-
-        for log in logs:
-            total_proc += log.items_processed
-            total_fail += log.items_failed
-            if "cleaned" in log.details:
-                cleaned_list.extend(log.details["cleaned"])
-
-        report += f"✅ Feldolgozott modellek: {total_proc}\n"
-        report += f"❌ Hibás/Sikertelen: {total_fail}\n"
-        report += f"🧹 AI névtisztítások száma: {len(cleaned_list)}\n\n"
+        total_proc = sum(log.items_processed for log in logs)
+        total_fail = sum(log.items_failed for log in logs)
         
-        if cleaned_list:
-            report += "Példák a tisztított nevekre:\n"
-            for item in cleaned_list[:10]: # Csak az első 10-et listázzuk
-                report += f"  - {item}\n"
+        report += f"✅ Feldolgozott egységek: {total_proc}\n"
+        report += f"❌ Sikertelen műveletek: {total_fail}\n"
+        
+        if logs:
+            report += "\nAktív robotok állapota:\n"
+            for log in logs:
+                status = "🟢 OK" if log.items_failed == 0 else "🔴 HIBA"
+                report += f"  - {log.process_name}: {log.items_processed} feldolgozva ({status})\n"
 
         print(report)
-        # Itt hívható az EmailManager.send(...)
         return report
 
 if __name__ == "__main__":

backend/app/scripts/seed_system_params.py

@@ -1,43 +1,32 @@
+# /opt/docker/dev/service_finder/backend/app/scripts/seed_system_params.py
 import asyncio
-import json
-from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
-from sqlalchemy.orm import sessionmaker
-from app.models import SystemParameter
-from app.core.config import settings
+from sqlalchemy import select
+from app.db.session import SessionLocal
+from app.models.system import SystemParameter
 
-async def seed_system():
-    engine = create_async_engine(settings.DATABASE_URL)
-    async_session = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
-
-    async with async_session() as session:
+async def seed_params():
+    async with SessionLocal() as db:
         params = [
             {
-                "key": "fuel_types",
-                "value": ["Benzin (95)", "Benzin (100)", "Dízel", "Prémium Dízel", "LPG", "Elektromos", "Hibrid"],
-                "description": "Rendszerben használható üzemanyag típusok"
+                "key": "VEHICLE_LIMIT",
+                "value": {"free": 1, "premium": 5, "vip": 50},
+                "category": "limits",
+                "description": "Járműszám korlátok előfizetési csomagonként"
             },
             {
-                "key": "currencies",
-                "value": ["HUF", "EUR", "USD", "GBP"],
-                "description": "Támogatott pénznemek"
-            },
-            {
-                "key": "expense_categories",
-                "value": ["Üzemanyag", "Szerviz", "Biztosítás", "Autópálya matrica", "Parkolás", "Adó", "Egyéb"],
-                "description": "Költség kategóriák"
+                "key": "xp_multipliers",
+                "value": {"manual_input": 1.0, "ocr_scan": 1.5, "verified_hunt": 2.0},
+                "category": "gamification"
             }
         ]
 
         for p in params:
-            # Megnézzük, létezik-e már
-            from sqlalchemy import select
-            result = await session.execute(select(SystemParameter).where(SystemParameter.key == p["key"]))
-            if not result.scalar_one_or_none():
-                new_param = SystemParameter(**p)
-                session.add(new_param)
+            stmt = select(SystemParameter).where(SystemParameter.key == p["key"])
+            if not (await db.execute(stmt)).scalar_one_or_none():
+                db.add(SystemParameter(**p))
         
-        await session.commit()
-        print("✅ Rendszer paraméterek sikeresen feltöltve!")
+        await db.commit()
+        print("✅ Sentinel paraméterek feltöltve.")
 
 if __name__ == "__main__":
-    asyncio.run(seed_system())
+    asyncio.run(seed_params())

backend/app/scripts/seed_v1_9_system.py

@@ -1,84 +1,31 @@
+# /opt/docker/dev/service_finder/backend/app/scripts/seed_v1_9_system.py
 import asyncio
 from sqlalchemy import select
-from sqlalchemy.orm import configure_mappers
 from app.db.session import SessionLocal
-
-# Fontos: Importálunk minden modellt a regisztrációhoz
-import app.models 
 from app.models.vehicle_definitions import VehicleType, FeatureDefinition
 
 async def seed_system_data():
-    # Kényszerített mapper konfiguráció a hiba ellen
-    try:
-        configure_mappers()
-    except Exception as e:
-        print(f"⚠️ Mapper figyelmeztetés (lehet, hogy már kész): {e}")
-
+    """ Alapvető típusok és extrák (Features) feltöltése. """
     async with SessionLocal() as db:
         try:
-            print("🚀 Kezdődik a rendszeradatok beoltása...")
+            print("🚀 Rendszer-blueprint betöltése...")
             
-            # 1. Jármű Fajták (Blueprints)
             types_data = [
                 {"code": "car", "name": "Személyautó", "icon": "directions_car"},
                 {"code": "motorcycle", "name": "Motorkerékpár", "icon": "moped"},
-                {"code": "truck", "name": "Teherautó/Kamion", "icon": "local_shipping"},
-                {"code": "bus", "name": "Autóbusz", "icon": "directions_bus"},
-                {"code": "boat", "name": "Hajó/Vitorlás", "icon": "sailing"},
-                {"code": "camper", "name": "Lakóautó", "icon": "rv_hookup"},
-                {"code": "machinery", "name": "Munkagép", "icon": "construction"},
-                {"code": "trailer", "name": "Utánfutó", "icon": "trailer"}
+                {"code": "truck", "name": "Teherautó", "icon": "local_shipping"},
+                {"code": "boat", "name": "Hajó", "icon": "sailing"}
             ]
 
-            type_id_map = {}
             for t_info in types_data:
                 stmt = select(VehicleType).where(VehicleType.code == t_info["code"])
-                res = await db.execute(stmt)
-                v_type = res.scalar_one_or_none()
-                if not v_type:
-                    v_type = VehicleType(**t_info)
-                    db.add(v_type)
-                    await db.flush()
-                type_id_map[t_info["code"]] = v_type.id
-
-            # 2. Extrák (Features) betöltése - A te listád alapján
-            features = {
-                "car": [
-                    ("Műszaki", "ABS (blokkolásgátló)"), ("Műszaki", "ESP (menetstabilizátor)"),
-                    ("Műszaki", "távolságtartó tempomat"), ("Beltér", "ISOFIX rendszer"),
-                    ("Multimédia", "Android Auto"), ("Multimédia", "Apple CarPlay")
-                ],
-                "truck": [
-                    ("Munkavégzés", "elektromos retarder"), ("Munkavégzés", "intarder"),
-                    ("Munkavégzés", "AdBlue"), ("Fülke", "hálófülke")
-                ],
-                "boat": [
-                    ("Műszaki", "orrsugárkormány"), ("Műszaki", "halradar"),
-                    ("Műszaki", "elektromos horgonycsörlő")
-                ]
-            }
-
-            for code, items in features.items():
-                t_id = type_id_map.get(code)
-                if not t_id: continue
-                for cat, name in items:
-                    stmt = select(FeatureDefinition).where(
-                        FeatureDefinition.name == name, 
-                        FeatureDefinition.vehicle_type_id == t_id
-                    )
-                    res = await db.execute(stmt)
-                    if not res.scalar_one_or_none():
-                        db.add(FeatureDefinition(
-                            vehicle_type_id=t_id, category=cat, name=name, data_type="boolean"
-                        ))
-
-            await db.commit()
-            print("✅ Minden alapadat (Types & Features) sikeresen betöltve!")
+                if not (await db.execute(stmt)).scalar_one_or_none():
+                    db.add(VehicleType(**t_info))
             
+            await db.commit()
+            print("✅ Blueprint kész.")
         except Exception as e:
-            await db.rollback()
-            print(f"❌ Végzetes hiba a feltöltés során: {e}")
-            raise e
+            print(f"❌ Hiba: {e}")
 
 if __name__ == "__main__":
     asyncio.run(seed_system_data())