refaktorálás javításai

backend/app/api/auth.py.old

@@ -1,132 +0,0 @@
-from datetime import timedelta
-from typing import Dict, Any
-from fastapi import APIRouter, HTTPException
-from app.core.config import settings
-from app.core.security import create_token, decode_token
-
-router = APIRouter(prefix="/auth", tags=["auth"])
-
-@router.post("/login")
-def login(payload: Dict[str, Any]):
-    """
-    payload:
-    {
-      "org_id": "<uuid>",
-      "login": "<username or email>",
-      "password": "<plain>"
-    }
-    """
-    from app.db.session import get_conn
-
-    conn = get_conn()
-    try:
-        cur = conn.cursor()
-        cur.execute("BEGIN;")
-
-        org_id = (payload.get("org_id") or "").strip()
-        login_id = (payload.get("login") or "").strip()
-        password = payload.get("password") or ""
-
-        if not org_id or not login_id or not password:
-            raise HTTPException(status_code=400, detail="org_id, login, password required")
-
-        # RLS miatt kötelező: org kontextus beállítás
-        cur.execute("SELECT set_config('app.tenant_org_id', %s, false);", (org_id,))
-
-        # account + credential
-        cur.execute(
-            """
-            SELECT
-              a.account_id::text,
-              a.org_id::text,
-              a.username::text,
-              a.email::text,
-              c.password_hash,
-              c.is_active
-            FROM app.account a
-            JOIN app.account_credential c ON c.account_id = a.account_id
-            WHERE a.org_id = %s::uuid
-              AND (a.username = %s::citext OR a.email = %s::citext)
-              AND c.is_active = true
-            LIMIT 1;
-            """,
-            (org_id, login_id, login_id),
-        )
-
-        row = cur.fetchone()
-        if not row:
-            raise HTTPException(status_code=401, detail="Invalid credentials")
-
-        account_id, org_id_db, username, email, password_hash, cred_active = row
-
-        # Jelszó ellenőrzés pgcrypto-val: crypt(plain, stored_hash) = stored_hash
-        cur.execute("SELECT crypt(%s, %s) = %s;", (password, password_hash, password_hash))
-        ok = cur.fetchone()[0]
-        if not ok:
-            raise HTTPException(status_code=401, detail="Invalid credentials")
-
-        # MVP: role később membershipből; most fixen tenant_admin
-        role_code = "tenant_admin"
-        is_platform_admin = False
-
-        access = create_token(
-            {
-                "sub": account_id,
-                "org_id": org_id_db,
-                "role": role_code,
-                "is_platform_admin": is_platform_admin,
-                "type": "access",
-            },
-            settings.JWT_SECRET,
-            timedelta(minutes=settings.JWT_ACCESS_MINUTES),
-        )
-
-        refresh = create_token(
-            {
-                "sub": account_id,
-                "org_id": org_id_db,
-                "role": role_code,
-                "is_platform_admin": is_platform_admin,
-                "type": "refresh",
-            },
-            settings.JWT_SECRET,
-            timedelta(days=settings.JWT_REFRESH_DAYS),
-        )
-
-        conn.commit()
-        return {"access_token": access, "refresh_token": refresh, "token_type": "bearer"}
-    except HTTPException:
-        conn.rollback()
-        raise
-    except Exception as e:
-        conn.rollback()
-        raise HTTPException(status_code=500, detail=str(e))
-    finally:
-        conn.close()
-
-
-@router.post("/refresh")
-def refresh_token(payload: Dict[str, Any]):
-    token = payload.get("refresh_token") or ""
-    if not token:
-        raise HTTPException(status_code=400, detail="refresh_token required")
-
-    try:
-        claims = decode_token(token, settings.JWT_SECRET)
-        if claims.get("type") != "refresh":
-            raise HTTPException(status_code=401, detail="Invalid refresh token type")
-
-        access = create_token(
-            {
-                "sub": claims.get("sub"),
-                "org_id": claims.get("org_id"),
-                "role": claims.get("role"),
-                "is_platform_admin": claims.get("is_platform_admin", False),
-                "type": "access",
-            },
-            settings.JWT_SECRET,
-            timedelta(minutes=settings.JWT_ACCESS_MINUTES),
-        )
-        return {"access_token": access, "token_type": "bearer"}
-    except Exception:
-        raise HTTPException(status_code=401, detail="Invalid or expired refresh token")

backend/app/api/recommend.py

@@ -10,7 +10,7 @@ router = APIRouter()
 async def provider_inbox(provider_id: str, db: AsyncSession = Depends(get_db)):
     """ Aszinkron szerviz-postaláda lekérdezés. """
     query = text("""
-        SELECT * FROM data.service_profiles 
+        SELECT * FROM marketplace.service_profiles
         WHERE id = :p_id
     """)
     result = await db.execute(query, {"p_id": provider_id})

backend/app/api/v1/api.py

@@ -3,7 +3,7 @@ from fastapi import APIRouter
 from app.api.v1.endpoints import (
     auth, catalog, assets, organizations, documents,
     services, admin, expenses, evidence, social, security,
-    billing
+    billing, finance_admin, analytics, vehicles
 )
 
 api_router = APIRouter()
@@ -19,4 +19,7 @@ api_router.include_router(admin.router, prefix="/admin", tags=["Admin Control Ce
 api_router.include_router(evidence.router, prefix="/evidence", tags=["Evidence & OCR (Robot 3)"])
 api_router.include_router(expenses.router, prefix="/expenses", tags=["Fleet Expenses (TCO)"])
 api_router.include_router(social.router, prefix="/social", tags=["Social & Leaderboard"])
-api_router.include_router(security.router, prefix="/security", tags=["Dual Control (Security)"])
+api_router.include_router(security.router, prefix="/security", tags=["Dual Control (Security)"])
+api_router.include_router(finance_admin.router, prefix="/finance/issuers", tags=["finance-admin"])
+api_router.include_router(analytics.router, prefix="/analytics", tags=["Analytics"])
+api_router.include_router(vehicles.router, prefix="/vehicles", tags=["Vehicles"])

backend/app/api/v1/endpoints/admin.py

@@ -7,20 +7,23 @@ from datetime import datetime, timedelta
 
 from app.api import deps
 from app.models.identity import User, UserRole # JAVÍTVA: Központi import
-from app.models.system import SystemParameter
+from app.models.system import SystemParameter, ParameterScope
+from app.services.system_service import system_service
 # JAVÍTVA: Security audit modellek
 from app.models.audit import SecurityAuditLog, OperationalLog
 # JAVÍTVA: Ezek a modellek a security.py-ból jönnek (ha ott vannak)
 from app.models.security import PendingAction, ActionStatus
 
 from app.services.security_service import security_service
-from app.services.translation_service import TranslationService 
-from pydantic import BaseModel
+from app.services.translation_service import TranslationService
+from app.services.odometer_service import OdometerService
+from pydantic import BaseModel, Field
+from typing import Optional as Opt
 
 class ConfigUpdate(BaseModel):
     key: str
     value: Any
-    scope_level: str = "global"
+    scope_level: ParameterScope = ParameterScope.GLOBAL
     scope_id: Optional[str] = None
     category: str = "general"
 
@@ -43,13 +46,13 @@ async def get_system_health(
     stats = {}
     
     # Adatbázis statisztikák (Nyers SQL marad, mert hatékony)
-    user_stats = await db.execute(text("SELECT subscription_plan, count(*) FROM data.users GROUP BY subscription_plan"))
+    user_stats = await db.execute(text("SELECT subscription_plan, count(*) FROM identity.users GROUP BY subscription_plan"))
     stats["user_distribution"] = {row[0]: row[1] for row in user_stats}
     
-    asset_count = await db.execute(text("SELECT count(*) FROM data.assets"))
+    asset_count = await db.execute(text("SELECT count(*) FROM vehicle.assets"))
     stats["total_assets"] = asset_count.scalar()
     
-    org_count = await db.execute(text("SELECT count(*) FROM data.organizations"))
+    org_count = await db.execute(text("SELECT count(*) FROM fleet.organizations"))
     stats["total_organizations"] = org_count.scalar()
 
     # JAVÍTVA: Biztonsági státusz az új SecurityAuditLog alapján
@@ -101,7 +104,7 @@ async def set_parameter(
     admin: User = Depends(check_admin_access)
 ):
     query = text("""
-        INSERT INTO data.system_parameters (key, value, scope_level, scope_id, category, last_modified_by)
+        INSERT INTO system.system_parameters (key, value, scope_level, scope_id, category, last_modified_by)
         VALUES (:key, :val, :sl, :sid, :cat, :user)
         ON CONFLICT (key, scope_level, scope_id) 
         DO UPDATE SET 
@@ -122,10 +125,114 @@ async def set_parameter(
     await db.commit()
     return {"status": "success", "message": f"'{config.key}' frissítve."}
 
+@router.get("/parameters/scoped", tags=["Dynamic Configuration"])
+async def get_scoped_parameter(
+    key: str,
+    user_id: Optional[str] = None,
+    region_id: Optional[str] = None,
+    country_code: Optional[str] = None,
+    db: AsyncSession = Depends(deps.get_db),
+    admin: User = Depends(check_admin_access)
+):
+    """
+    Hierarchikus paraméterlekérdezés a következő prioritással:
+    User > Region > Country > Global.
+    """
+    value = await system_service.get_scoped_parameter(
+        db, key, user_id, region_id, country_code, default=None
+    )
+    if value is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Paraméter '{key}' nem található a megadott scope-okban."
+        )
+    return {"key": key, "value": value}
+
 @router.post("/translations/sync", tags=["System Utilities"])
 async def sync_translations_to_json(
     db: AsyncSession = Depends(deps.get_db),
     admin: User = Depends(check_admin_access)
 ):
     await TranslationService.export_to_json(db)
-    return {"message": "JSON fájlok frissítve."}
+    return {"message": "JSON fájlok frissítve."}
+
+
+# ==================== SMART ODOMETER ADMIN API ====================
+
+class OdometerStatsResponse(BaseModel):
+    vehicle_id: int
+    last_recorded_odometer: int
+    last_recorded_date: datetime
+    daily_avg_distance: float
+    estimated_current_odometer: float
+    confidence_score: float
+    manual_override_avg: Opt[float]
+    is_confidence_high: bool = Field(..., description="True ha confidence_score >= threshold")
+
+class ManualOverrideRequest(BaseModel):
+    daily_avg: Opt[float] = Field(None, description="Napi átlagos kilométer (km/nap). Ha null, törli a manuális beállítást.")
+
+@router.get("/odometer/{vehicle_id}", tags=["Smart Odometer"])
+async def get_odometer_stats(
+    vehicle_id: int,
+    db: AsyncSession = Depends(deps.get_db),
+    admin: User = Depends(check_admin_access)
+):
+    """
+    Jármű kilométeróra statisztikáinak lekérése.
+    
+    A rendszer automatikusan frissíti a statisztikákat, ha szükséges.
+    """
+    # Frissítjük a statisztikákat
+    odometer_state = await OdometerService.update_vehicle_stats(db, vehicle_id)
+    if not odometer_state:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Jármű nem található ID: {vehicle_id}"
+        )
+    
+    # Confidence threshold lekérése
+    confidence_threshold = await OdometerService.get_system_param(
+        db, 'ODOMETER_CONFIDENCE_THRESHOLD', 0.5
+    )
+    
+    return OdometerStatsResponse(
+        vehicle_id=odometer_state.vehicle_id,
+        last_recorded_odometer=odometer_state.last_recorded_odometer,
+        last_recorded_date=odometer_state.last_recorded_date,
+        daily_avg_distance=float(odometer_state.daily_avg_distance),
+        estimated_current_odometer=float(odometer_state.estimated_current_odometer),
+        confidence_score=odometer_state.confidence_score,
+        manual_override_avg=float(odometer_state.manual_override_avg) if odometer_state.manual_override_avg else None,
+        is_confidence_high=odometer_state.confidence_score >= confidence_threshold
+    )
+
+@router.patch("/odometer/{vehicle_id}", tags=["Smart Odometer"])
+async def set_odometer_manual_override(
+    vehicle_id: int,
+    request: ManualOverrideRequest,
+    db: AsyncSession = Depends(deps.get_db),
+    admin: User = Depends(check_admin_access)
+):
+    """
+    Adminisztrátori manuális átlag beállítása a kilométeróra becsléshez.
+    
+    Ha a user csal vagy hibás az adat, az admin ezzel felülírhatja az automatikus számítást.
+    """
+    odometer_state = await OdometerService.set_manual_override(
+        db, vehicle_id, request.daily_avg
+    )
+    
+    if not odometer_state:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Jármű nem található ID: {vehicle_id}"
+        )
+    
+    action = "beállítva" if request.daily_avg is not None else "törölve"
+    return {
+        "status": "success",
+        "message": f"Manuális átlag {action}: {request.daily_avg} km/nap",
+        "vehicle_id": vehicle_id,
+        "manual_override_avg": odometer_state.manual_override_avg
+    }

backend/app/api/v1/endpoints/analytics.py

@@ -0,0 +1,196 @@
+"""
+Analytics API endpoints for TCO (Total Cost of Ownership) dashboard.
+"""
+
+import logging
+import uuid
+from typing import List, Optional
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api import deps
+from app.schemas.analytics import TCOSummaryResponse, TCOErrorResponse
+from app.services.analytics_service import TCOAnalytics
+from app.models import Vehicle
+from app.models.organization import OrganizationMember
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+async def verify_vehicle_access(
+    vehicle_id: uuid.UUID,
+    db: AsyncSession,
+    current_user
+) -> Vehicle:
+    """
+    Verify that the current user has access to the vehicle (either as owner or via organization).
+    Raises HTTP 404 if vehicle not found, 403 if access denied.
+    """
+    # 1. Check if vehicle exists
+    vehicle = await db.get(Vehicle, vehicle_id)
+    if not vehicle:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Vehicle with ID {vehicle_id} not found."
+        )
+    
+    # 2. Check if user is superadmin (global access)
+    if current_user.role == "superadmin":
+        return vehicle
+    
+    # 3. Check if user is member of the vehicle's organization
+    #    (Vehicle.organization_id matches user's organization membership)
+    # First, get user's organization memberships
+    from sqlalchemy import select
+    stmt = select(OrganizationMember).where(
+        OrganizationMember.user_id == current_user.id,
+        OrganizationMember.organization_id == vehicle.organization_id
+    )
+    result = await db.execute(stmt)
+    membership = result.scalar_one_or_none()
+    
+    if membership:
+        return vehicle
+    
+    # 4. If user is not a member, check if they have fleet manager role with cross-org access
+    # (This could be extended based on RBAC)
+    # For now, deny access
+    raise HTTPException(
+        status_code=status.HTTP_403_FORBIDDEN,
+        detail="You do not have permission to access this vehicle's analytics."
+    )
+
+
+@router.get(
+    "/{vehicle_id}/summary",
+    response_model=TCOSummaryResponse,
+    responses={
+        404: {"model": TCOErrorResponse, "description": "Vehicle not found"},
+        403: {"model": TCOErrorResponse, "description": "Access denied"},
+        500: {"model": TCOErrorResponse, "description": "Internal server error"},
+    },
+    summary="Get TCO summary for a vehicle",
+    description="Returns Total Cost of Ownership analytics for a specific vehicle, "
+                "including user-specific costs, lifetime costs, and benchmark comparisons."
+)
+async def get_tco_summary(
+    vehicle_id: uuid.UUID,
+    db: AsyncSession = Depends(deps.get_db),
+    current_user = Depends(deps.get_current_active_user),
+):
+    """
+    Retrieve TCO analytics for a vehicle.
+    
+    Steps:
+    1. Verify user has access to the vehicle.
+    2. Use TCOAnalytics service to compute user TCO, lifetime TCO, and benchmark.
+    3. Transform results into the response schema.
+    """
+    try:
+        # Access verification
+        vehicle = await verify_vehicle_access(vehicle_id, db, current_user)
+        
+        analytics = TCOAnalytics()
+        
+        # 1. User TCO (current user's organization)
+        user_tco_result = await analytics.get_user_tco(
+            db=db,
+            organization_id=current_user.organization_id or vehicle.organization_id,
+            currency_target="HUF",
+            include_categories=None,  # all categories
+        )
+        
+        # 2. Lifetime TCO (across all owners, anonymized)
+        lifetime_tco_result = await analytics.get_vehicle_lifetime_tco(
+            db=db,
+            vehicle_model_id=vehicle.vehicle_model_id,
+            currency_target="HUF",
+            anonymize=True,
+        )
+        
+        # 3. Benchmark TCO (global benchmark for similar vehicles)
+        benchmark_result = await analytics.get_global_benchmark(
+            db=db,
+            vehicle_model_id=vehicle.vehicle_model_id,
+            currency_target="HUF",
+        )
+        
+        # Transform results into schema objects
+        # Note: This is a simplified transformation; you may need to adapt based on actual service output.
+        user_tco_list = []
+        if "by_category" in user_tco_result:
+            for cat_code, cat_data in user_tco_result["by_category"].items():
+                # Calculate percentage
+                total = user_tco_result.get("total_amount", 0)
+                percentage = (cat_data["total"] / total * 100) if total > 0 else 0
+                user_tco_list.append({
+                    "category_id": 0,  # TODO: map from category code to ID
+                    "category_code": cat_code,
+                    "category_name": cat_data.get("name", cat_code),
+                    "amount": cat_data["total"],
+                    "currency": user_tco_result.get("currency", "HUF"),
+                    "amount_huf": cat_data["total"],  # already in HUF
+                    "percentage": round(percentage, 2),
+                })
+        
+        lifetime_tco_list = []
+        if "by_category" in lifetime_tco_result:
+            for cat_code, cat_data in lifetime_tco_result["by_category"].items():
+                total = lifetime_tco_result.get("total_lifetime_cost", 0)
+                percentage = (cat_data["total"] / total * 100) if total > 0 else 0
+                lifetime_tco_list.append({
+                    "category_id": 0,
+                    "category_code": cat_code,
+                    "category_name": cat_data.get("name", cat_code),
+                    "amount": cat_data["total"],
+                    "currency": lifetime_tco_result.get("currency", "HUF"),
+                    "amount_huf": cat_data["total"],
+                    "percentage": round(percentage, 2),
+                })
+        
+        benchmark_tco_list = []
+        if "by_category" in benchmark_result:
+            for cat_code, cat_data in benchmark_result["by_category"].items():
+                total = benchmark_result.get("total_cost_sum", 0)
+                percentage = (cat_data["average"] / total * 100) if total > 0 else 0
+                benchmark_tco_list.append({
+                    "category_id": 0,
+                    "category_code": cat_code,
+                    "category_name": cat_data.get("name", cat_code),
+                    "amount": cat_data["average"],
+                    "currency": benchmark_result.get("currency", "HUF"),
+                    "amount_huf": cat_data["average"],
+                    "percentage": round(percentage, 2),
+                })
+        
+        # Calculate cost per km if odometer data available
+        cost_per_km = None
+        if vehicle.odometer and vehicle.odometer > 0:
+            total_cost = user_tco_result.get("total_amount", 0)
+            cost_per_km = total_cost / vehicle.odometer
+        
+        stats = {
+            "total_cost": user_tco_result.get("total_amount", 0),
+            "cost_per_km": cost_per_km,
+            "total_transactions": user_tco_result.get("total_transactions", 0),
+            "date_range": user_tco_result.get("date_range"),
+        }
+        
+        return TCOSummaryResponse(
+            vehicle_id=vehicle_id,
+            user_tco=user_tco_list,
+            lifetime_tco=lifetime_tco_list,
+            benchmark_tco=benchmark_tco_list,
+            stats=stats,
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.exception(f"Unexpected error in TCO summary for vehicle {vehicle_id}: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Internal server error: {str(e)}"
+        )

backend/app/api/v1/endpoints/evidence.py

@@ -10,7 +10,7 @@ router = APIRouter()
 
 @router.post("/scan-registration")
 async def scan_registration_document(file: UploadFile = File(...), db: AsyncSession = Depends(get_db), current_user: User = Depends(get_current_user)):
-    stmt_limit = text("SELECT (value->>:plan)::int FROM data.system_parameters WHERE key = 'VEHICLE_LIMIT'")
+    stmt_limit = text("SELECT (value->>:plan)::int FROM system.system_parameters WHERE key = 'VEHICLE_LIMIT'")
     res = await db.execute(stmt_limit, {"plan": current_user.subscription_plan or "free"})
     max_allowed = res.scalar() or 1
 

backend/app/api/v1/endpoints/finance_admin.py

@@ -0,0 +1,77 @@
+# /opt/docker/dev/service_finder/backend/app/api/v1/endpoints/finance_admin.py
+"""
+Finance Admin API endpoints for managing Issuers with strict RBAC protection.
+Only users with rank >= 90 (Superadmin/Finance Admin) can access these endpoints.
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+from typing import List
+
+from app.api import deps
+from app.models.identity import User, UserRole
+from app.models.finance import Issuer
+from app.schemas.finance import IssuerResponse, IssuerUpdate
+
+router = APIRouter()
+
+
+async def check_finance_admin_access(
+    current_user: User = Depends(deps.get_current_active_user)
+):
+    """
+    RBAC protection: only users with rank >= 90 (Superadmin/Finance Admin) can access.
+    In our system, this translates to role being 'superadmin' or 'admin'.
+    """
+    if current_user.role not in [UserRole.superadmin, UserRole.admin]:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Not enough permissions. Rank >= 90 (Superadmin/Finance Admin) required."
+        )
+    return current_user
+
+
+@router.get("/", response_model=List[IssuerResponse], tags=["finance-admin"])
+async def list_issuers(
+    db: AsyncSession = Depends(deps.get_db),
+    admin: User = Depends(check_finance_admin_access)
+):
+    """
+    List all Issuers (billing entities).
+    Only accessible by Superadmin/Finance Admin (rank >= 90).
+    """
+    result = await db.execute(select(Issuer).order_by(Issuer.id))
+    issuers = result.scalars().all()
+    return issuers
+
+
+@router.patch("/{issuer_id}", response_model=IssuerResponse, tags=["finance-admin"])
+async def update_issuer(
+    issuer_id: int,
+    issuer_update: IssuerUpdate,
+    db: AsyncSession = Depends(deps.get_db),
+    admin: User = Depends(check_finance_admin_access)
+):
+    """
+    Update an Issuer's details (activate/deactivate, revenue limit, API config).
+    Only accessible by Superadmin/Finance Admin (rank >= 90).
+    """
+    result = await db.execute(select(Issuer).where(Issuer.id == issuer_id))
+    issuer = result.scalar_one_or_none()
+    
+    if not issuer:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Issuer with ID {issuer_id} not found."
+        )
+    
+    # Update fields if provided
+    update_data = issuer_update.model_dump(exclude_unset=True)
+    for field, value in update_data.items():
+        setattr(issuer, field, value)
+    
+    await db.commit()
+    await db.refresh(issuer)
+    
+    return issuer

backend/app/api/v1/endpoints/reports.py

@@ -15,7 +15,7 @@ async def get_vehicle_summary(vehicle_id: str, db: AsyncSession = Depends(get_db
             category, 
             SUM(amount) as total_amount,
             COUNT(*) as transaction_count
-        FROM data.vehicle_expenses
+        FROM vehicle.vehicle_expenses
         WHERE vehicle_id = :v_id
         GROUP BY category
     """)
@@ -40,7 +40,7 @@ async def get_monthly_trends(vehicle_id: str, db: AsyncSession = Depends(get_db)
         SELECT 
             TO_CHAR(date, 'YYYY-MM') as month,
             SUM(amount) as monthly_total
-        FROM data.vehicle_expenses
+        FROM vehicle.vehicle_expenses
         WHERE vehicle_id = :v_id
         GROUP BY month
         ORDER BY month DESC

backend/app/api/v1/endpoints/search.py

@@ -10,12 +10,12 @@ router = APIRouter()
 
 @router.get("/match")
 async def match_service(lat: float, lng: float, radius: int = 20, db: AsyncSession = Depends(get_db), current_user = Depends(get_current_user)):
-    # PostGIS alapú keresés a data.branches táblában (a régi locations helyett)
+    # PostGIS alapú keresés a fleet.branches táblában (a régi locations helyett)
     query = text("""
         SELECT o.id, o.name, b.city,
         ST_Distance(b.location, ST_SetSRID(ST_MakePoint(:lng, :lat), 4326)::geography) / 1000 as distance
-        FROM data.organizations o
-        JOIN data.branches b ON o.id = b.organization_id
+        FROM fleet.organizations o
+        JOIN fleet.branches b ON o.id = b.organization_id
         WHERE o.is_active = True AND b.is_active = True
         AND ST_DWithin(b.location, ST_SetSRID(ST_MakePoint(:lng, :lat), 4326)::geography, :r * 1000)
         ORDER BY distance ASC

backend/app/api/v1/endpoints/services.py

@@ -1,10 +1,18 @@
-from fastapi import APIRouter, Depends, Form, Query, HTTPException
+from fastapi import APIRouter, Depends, Form, Query, HTTPException, status
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select, and_, text
 from typing import List, Optional
 from app.db.session import get_db
 from app.services.gamification_service import GamificationService
 from app.models.service import ServiceProfile, ExpertiseTag, ServiceExpertise
+from app.services.marketplace_service import (
+    create_verified_review,
+    get_service_reviews,
+    can_user_review_service
+)
+from app.schemas.social import ServiceReviewCreate, ServiceReviewResponse
+from app.api.deps import get_current_user
+from app.models.identity import User
 
 router = APIRouter()
 
@@ -19,7 +27,7 @@ async def register_service_hunt(
     """ Új szerviz-jelölt rögzítése a staging táblába jutalompontért. """
     # Új szerviz-jelölt rögzítése
     await db.execute(text("""
-        INSERT INTO data.service_staging (name, fingerprint, status, raw_data)
+        INSERT INTO marketplace.service_staging (name, fingerprint, status, raw_data)
         VALUES (:n, :f, 'pending', jsonb_build_object('lat', :lat, 'lng', :lng))
     """), {"n": name, "f": f"{name}-{lat}-{lng}", "lat": lat, "lng": lng})
     
@@ -55,4 +63,76 @@ async def search_services(
     result = await db.execute(query.distinct())
     services = result.scalars().all()
     
-    return services
+    return services
+
+
+# --- ⭐ VERIFIED SERVICE REVIEWS (Social 3 - #66) ---
+
+@router.post("/{service_id}/reviews", response_model=ServiceReviewResponse, status_code=status.HTTP_201_CREATED)
+async def create_service_review(
+    service_id: int,
+    review_data: ServiceReviewCreate,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Verifikált szerviz értékelés beküldése.
+    Csak igazolt pénzügyi tranzakció után lehetséges (transaction_id kötelező).
+    """
+    try:
+        review = await create_verified_review(
+            db=db,
+            service_id=service_id,
+            user_id=current_user.id,
+            transaction_id=review_data.transaction_id,
+            review_data=review_data
+        )
+        return review
+    except ValueError as e:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+    except IntegrityError as e:
+        raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(e))
+
+
+@router.get("/{service_id}/reviews", response_model=dict)
+async def list_service_reviews(
+    service_id: int,
+    skip: int = Query(0, ge=0),
+    limit: int = Query(20, ge=1, le=100),
+    verified_only: bool = Query(True),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Szerviz értékeléseinek lapozható listázása.
+    """
+    reviews, total = await get_service_reviews(
+        db=db,
+        service_id=service_id,
+        skip=skip,
+        limit=limit,
+        verified_only=verified_only
+    )
+    return {
+        "reviews": reviews,
+        "total": total,
+        "skip": skip,
+        "limit": limit
+    }
+
+
+@router.get("/{service_id}/reviews/check")
+async def check_review_eligibility(
+    service_id: int,
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """
+    Ellenőrzi, hogy a felhasználó értékelheti‑e a szervizt.
+    """
+    can_review, reason = await can_user_review_service(db, current_user.id, service_id)
+    return {
+        "can_review": can_review,
+        "reason": reason,
+        "user_id": current_user.id,
+        "service_id": service_id
+    }

backend/app/api/v1/endpoints/users.py

@@ -1,11 +1,14 @@
 from fastapi import APIRouter, Depends
 from sqlalchemy.ext.asyncio import AsyncSession
+from typing import Dict, Any
 
 from app.api.deps import get_db, get_current_user
 from app.schemas.user import UserResponse
-from app.models.user import User
+from app.models.identity import User
+from app.services.trust_engine import TrustEngine
 
 router = APIRouter()
+trust_engine = TrustEngine()
 
 @router.get("/me", response_model=UserResponse)
 async def read_users_me(
@@ -14,3 +17,26 @@ async def read_users_me(
 ):
     """Visszaadja a bejelentkezett felhasználó profilját"""
     return current_user
+
+@router.get("/me/trust")
+async def get_user_trust(
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+    force_recalculate: bool = False,
+) -> Dict[str, Any]:
+    """
+    Visszaadja a felhasználó Gondos Gazda Index (Trust Score) értékét.
+    
+    A számítás dinamikusan betölti a paramétereket a SystemParameter rendszerből
+    (Global/Country/Region/User hierarchia).
+    
+    Paraméterek:
+    - force_recalculate: Ha True, akkor újraszámolja a trust score-t
+      (alapértelmezetten cache-elt értéket ad vissza, ha kevesebb mint 24 órája számoltuk)
+    """
+    trust_data = await trust_engine.calculate_user_trust(
+        db=db,
+        user_id=current_user.id,
+        force_recalculate=force_recalculate
+    )
+    return trust_data

backend/app/api/v1/endpoints/vehicles.py

@@ -0,0 +1,142 @@
+"""
+Jármű értékelési végpontok a Social 1 modulhoz.
+"""
+import uuid
+from typing import List
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, and_
+from sqlalchemy.orm import selectinload
+
+from app.db.session import get_db
+from app.api.deps import get_current_user
+from app.models.vehicle import VehicleUserRating
+from app.models.vehicle_definitions import VehicleModelDefinition
+from app.models.identity import User
+from app.schemas.vehicle import VehicleRatingCreate, VehicleRatingResponse
+
+router = APIRouter()
+
+
+@router.post("/{vehicle_id}/ratings", response_model=VehicleRatingResponse, status_code=status.HTTP_201_CREATED)
+async def create_vehicle_rating(
+    vehicle_id: int,
+    rating: VehicleRatingCreate,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Értékelés beküldése egy járműhöz.
+    Csak a jármű tulajdonosa (vagy jogosult felhasználó) értékelhet.
+    Egy felhasználó csak egyszer értékelhet egy adott járművet.
+    """
+    # 1. Ellenőrizzük, hogy a jármű létezik-e
+    vehicle = await db.scalar(
+        select(VehicleModelDefinition).where(VehicleModelDefinition.id == vehicle_id)
+    )
+    if not vehicle:
+        raise HTTPException(status_code=404, detail="Jármű nem található")
+
+    # 2. Ellenőrizzük, hogy a felhasználó jogosult-e értékelni (jelenleg csak tulajdonos)
+    # TODO: Később kibővíthető más jogosultságokkal is
+    # Most feltételezzük, hogy mindenki értékelhet, de csak egyszer
+
+    # 3. Ellenőrizzük, hogy már létezik-e értékelés ettől a felhasználótól ehhez a járműhöz
+    existing_rating = await db.scalar(
+        select(VehicleUserRating).where(
+            and_(
+                VehicleUserRating.vehicle_id == vehicle_id,
+                VehicleUserRating.user_id == current_user.id
+            )
+        )
+    )
+    if existing_rating:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail="Már értékelted ezt a járművet. Csak egy értékelés engedélyezett felhasználónként."
+        )
+
+    # 4. Hozzuk létre az új értékelést
+    new_rating = VehicleUserRating(
+        vehicle_id=vehicle_id,
+        user_id=current_user.id,
+        driving_experience=rating.driving_experience,
+        reliability=rating.reliability,
+        comfort=rating.comfort,
+        consumption_satisfaction=rating.consumption_satisfaction,
+        comment=rating.comment
+    )
+
+    db.add(new_rating)
+    await db.commit()
+    await db.refresh(new_rating)
+
+    # 5. Átlagpontszám számítása
+    average_score = new_rating.average_score
+
+    # 6. Válasz összeállítása
+    return VehicleRatingResponse(
+        id=new_rating.id,
+        vehicle_id=new_rating.vehicle_id,
+        user_id=new_rating.user_id,
+        driving_experience=new_rating.driving_experience,
+        reliability=new_rating.reliability,
+        comfort=new_rating.comfort,
+        consumption_satisfaction=new_rating.consumption_satisfaction,
+        comment=new_rating.comment,
+        average_score=average_score,
+        created_at=new_rating.created_at,
+        updated_at=new_rating.updated_at
+    )
+
+
+@router.get("/{vehicle_id}/ratings", response_model=List[VehicleRatingResponse])
+async def get_vehicle_ratings(
+    vehicle_id: int,
+    skip: int = 0,
+    limit: int = 100,
+    db: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    Az összes értékelés lekérése egy adott járműhöz.
+    """
+    # Ellenőrizzük, hogy a jármű létezik-e
+    vehicle = await db.scalar(
+        select(VehicleModelDefinition).where(VehicleModelDefinition.id == vehicle_id)
+    )
+    if not vehicle:
+        raise HTTPException(status_code=404, detail="Jármű nem található")
+
+    # Lekérjük az értékeléseket
+    stmt = (
+        select(VehicleUserRating)
+        .where(VehicleUserRating.vehicle_id == vehicle_id)
+        .order_by(VehicleUserRating.created_at.desc())
+        .offset(skip)
+        .limit(limit)
+    )
+    
+    result = await db.scalars(stmt)
+    ratings = result.all()
+
+    # Átalakítás válasz sémává
+    response_ratings = []
+    for rating in ratings:
+        response_ratings.append(
+            VehicleRatingResponse(
+                id=rating.id,
+                vehicle_id=rating.vehicle_id,
+                user_id=rating.user_id,
+                driving_experience=rating.driving_experience,
+                reliability=rating.reliability,
+                comfort=rating.comfort,
+                consumption_satisfaction=rating.consumption_satisfaction,
+                comment=rating.comment,
+                average_score=rating.average_score,
+                created_at=rating.created_at,
+                updated_at=rating.updated_at
+            )
+        )
+
+    return response_ratings

backend/app/core/config.py

@@ -126,7 +126,7 @@ class Settings(BaseSettings):
     # --- Dinamikus Admin Motor (Sértetlenül hagyva) ---
     async def get_db_setting(self, db: AsyncSession, key_name: str, default: Any = None) -> Any:
         try:
-            query = text("SELECT value FROM data.system_parameters WHERE key = :key")
+            query = text("SELECT value FROM system.system_parameters WHERE key = :key")
             result = await db.execute(query, {"key": key_name})
             row = result.fetchone()
             if row and row[0] is not None:

backend/app/database.py

@@ -3,10 +3,18 @@ from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sess
 from sqlalchemy.orm import DeclarativeBase
 from app.core.config import settings
 
-# Most már settings.SQLALCHEMY_DATABASE_URI létezik a property miatt!
+# 1. Base definíciója - Ezt importálják a modellek
+class Base(DeclarativeBase):
+    """
+    Központi SQLAlchemy Base osztály.
+    A modellek a 'from app.database import Base' segítségével érik el.
+    """
+    pass
+
+# 2. Engine és SessionLocal beállítása
 engine = create_async_engine(
     str(settings.SQLALCHEMY_DATABASE_URI),
-    echo=settings.DEBUG_MODE, 
+    echo=settings.DEBUG_MODE,
     pool_size=20,
     max_overflow=10,
     pool_pre_ping=True,
@@ -20,5 +28,20 @@ AsyncSessionLocal = async_sessionmaker(
     expire_on_commit=False
 )
 
-class Base(DeclarativeBase):
-    pass
+# 3. A "Körforgás-törő" függvény
+def ensure_models_loaded():
+    """
+    Dinamikusan betölti az összes modellt a regiszter segítségével.
+    Helyi importot használunk, hogy elkerüljük a körkörös függőséget:
+    database -> registry -> database (Base)
+    """
+    try:
+        # Itt importálunk helyben, így a Base már létezik a memóriában
+        from app.models.registry import load_all_models
+        load_all_models()
+        print("✅ Adatbázis modellek regisztrálva a MetaData-ba.")
+    except ImportError as e:
+        print(f"⚠️ Hiba a modellek dinamikus betöltésekor: {e}")
+
+# Automatikus betöltés meghívása (opcionális, de ajánlott az API indításakor)
+# ensure_models_loaded()

backend/app/db/context.py.old

@@ -1,38 +0,0 @@
-from typing import Generator, Optional, Dict, Any
-from fastapi import Request
-from app.db.session import get_conn
-
-def _set_config(cur, key: str, value: str) -> None:
-    cur.execute("SELECT set_config(%s, %s, false);", (key, value))
-
-def db_tx(request: Request) -> Generator[Dict[str, Any], None, None]:
-    """
-    Egységes DB tranzakció + session context:
-    BEGIN
-      set_config(app.tenant_org_id, app.account_id, app.is_platform_admin)
-    COMMIT/ROLLBACK
-    """
-    conn = get_conn()
-    try:
-        cur = conn.cursor()
-        cur.execute("BEGIN;")
-
-        claims: Optional[dict] = getattr(request.state, "claims", None)
-        if claims:
-            org_id = claims.get("org_id") or ""
-            account_id = claims.get("sub") or ""
-            is_platform_admin = claims.get("is_platform_admin", False)
-
-            # Fontos: set_config stringeket vár
-            _set_config(cur, "app.tenant_org_id", str(org_id))
-            _set_config(cur, "app.account_id", str(account_id))
-            _set_config(cur, "app.is_platform_admin", "true" if is_platform_admin else "false")
-
-        yield {"conn": conn, "cur": cur}
-
-        conn.commit()
-    except Exception:
-        conn.rollback()
-        raise
-    finally:
-        conn.close()

backend/app/models/__init__.py

@@ -11,6 +11,7 @@ from .address import Address, GeoPostalCode, GeoStreet, GeoStreetType, Rating
 # 3. Jármű definíciók
 from .vehicle_definitions import VehicleModelDefinition, VehicleType, FeatureDefinition, ModelFeatureMap
 from .reference_data import ReferenceLookup
+from .vehicle import CostCategory, VehicleCost
 
 # 4. Szervezeti felépítés
 from .organization import Organization, OrganizationMember, OrganizationFinancials, OrganizationSalesAssignment, OrgType, OrgUserRole, Branch
@@ -21,19 +22,23 @@ from .asset import Asset, AssetCatalog, AssetCost, AssetEvent, AssetFinancials,
 # 6. Üzleti logika és előfizetések
 from .core_logic import SubscriptionTier, OrganizationSubscription, CreditTransaction, ServiceSpecialty
 from .payment import PaymentIntent, PaymentIntentStatus
+from .finance import Issuer, IssuerType
 
 # 7. Szolgáltatások és staging
 from .service import ServiceProfile, ExpertiseTag, ServiceExpertise, ServiceStaging, DiscoveryParameter
 
-# 8. Rendszer, Gamification és egyebek
+# 8. Közösségi és értékelési modellek (Social 3)
+from .social import ServiceProvider, Vote, Competition, UserScore, ServiceReview, ModerationStatus, SourceType
+
+# 9. Rendszer, Gamification és egyebek
 from .gamification import PointRule, LevelConfig, UserStats, Badge, UserBadge, PointsLedger
 
 # --- 2.2 ÚJDONSÁG: InternalNotification hozzáadása ---
-from .system import SystemParameter, InternalNotification 
+from .system import SystemParameter, InternalNotification
 
 from .document import Document
 from .translation import Translation
-from .audit import SecurityAuditLog, ProcessLog, FinancialLedger 
+from .audit import SecurityAuditLog, ProcessLog, FinancialLedger
 from .history import AuditLog, LogSeverity
 from .security import PendingAction
 from .legal import LegalDocument, LegalAcceptance
@@ -48,13 +53,16 @@ ServiceRecord = AssetEvent
 __all__ = [
     "Base", "User", "Person", "Wallet", "UserRole", "VerificationToken", "SocialAccount",
     "Organization", "OrganizationMember", "OrganizationSalesAssignment", "OrgType", "OrgUserRole",
-    "Asset", "AssetCatalog", "AssetCost", "AssetEvent", "AssetFinancials", 
+    "Asset", "AssetCatalog", "AssetCost", "AssetEvent", "AssetFinancials",
     "AssetTelemetry", "AssetReview", "ExchangeRate", "CatalogDiscovery",
     "Address", "GeoPostalCode", "GeoStreet", "GeoStreetType", "Branch",
     "PointRule", "LevelConfig", "UserStats", "Badge", "UserBadge", "Rating", "PointsLedger",
     
     # --- 2.2 ÚJDONSÁG KIEGÉSZÍTÉS ---
-    "SystemParameter", "InternalNotification", 
+    "SystemParameter", "InternalNotification",
+    
+    # Social models (Social 3)
+    "ServiceProvider", "Vote", "Competition", "UserScore", "ServiceReview", "ModerationStatus", "SourceType",
     
     "Document", "Translation", "PendingAction",
     "SubscriptionTier", "OrganizationSubscription", "CreditTransaction", "ServiceSpecialty",
@@ -64,6 +72,6 @@ __all__ = [
     "ServiceProfile", "ExpertiseTag", "ServiceExpertise", "ServiceStaging", "DiscoveryParameter",
     "Vehicle", "UserVehicle", "VehicleCatalog", "ServiceRecord", "VehicleModelDefinition", "ReferenceLookup",
     "VehicleType", "FeatureDefinition", "ModelFeatureMap", "LegalDocument", "LegalAcceptance",
-    "Location", "LocationType"
+    "Location", "LocationType", "Issuer", "IssuerType", "CostCategory", "VehicleCost"
 ]
 from app.models.payment import PaymentIntent, WithdrawalRequest

backend/app/models/address.py

@@ -12,7 +12,7 @@ from app.database import Base
 class GeoPostalCode(Base):
     """Irányítószám alapú földrajzi kereső tábla."""
     __tablename__ = "geo_postal_codes"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "system"}
     
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     country_code: Mapped[str] = mapped_column(String(5), default="HU")
@@ -22,16 +22,16 @@ class GeoPostalCode(Base):
 class GeoStreet(Base):
     """Utcajegyzék tábla."""
     __tablename__ = "geo_streets"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "system"}
     
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    postal_code_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("data.geo_postal_codes.id"))
+    postal_code_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("system.geo_postal_codes.id"))
     name: Mapped[str] = mapped_column(String(200), nullable=False, index=True)
 
 class GeoStreetType(Base):
     """Közterület jellege (utca, út, köz stb.)."""
     __tablename__ = "geo_street_types"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "system"}
     
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     name: Mapped[str] = mapped_column(String(50), unique=True, nullable=False)
@@ -39,10 +39,10 @@ class GeoStreetType(Base):
 class Address(Base):
     """Univerzális cím entitás GPS adatokkal kiegészítve."""
     __tablename__ = "addresses"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "system"}
 
     id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-    postal_code_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("data.geo_postal_codes.id"))
+    postal_code_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("system.geo_postal_codes.id"))
     
     street_name: Mapped[str] = mapped_column(String(200), nullable=False)
     street_type: Mapped[str] = mapped_column(String(50), nullable=False)
@@ -69,7 +69,7 @@ class Rating(Base):
         Index('idx_rating_org', 'target_organization_id'),
         Index('idx_rating_user', 'target_user_id'),
         Index('idx_rating_branch', 'target_branch_id'),
-        {"schema": "data"}
+        {"schema": "marketplace"}
     )
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
@@ -77,9 +77,9 @@ class Rating(Base):
     # MB 2.0: A felhasználók az identity sémában laknak!
     author_id: Mapped[int] = mapped_column(Integer, ForeignKey("identity.users.id"), nullable=False)
     
-    target_organization_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("data.organizations.id"))
+    target_organization_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("fleet.organizations.id"))
     target_user_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("identity.users.id"))
-    target_branch_id: Mapped[Optional[uuid.UUID]] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("data.branches.id"))
+    target_branch_id: Mapped[Optional[uuid.UUID]] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("fleet.branches.id"))
     
     score: Mapped[float] = mapped_column(Numeric(3, 2), nullable=False)
     comment: Mapped[Optional[str]] = mapped_column(Text)

backend/app/models/asset.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import uuid
 from datetime import datetime
 from typing import List, Optional, TYPE_CHECKING
-from sqlalchemy import String, Boolean, DateTime, ForeignKey, Numeric, text, Text, UniqueConstraint, BigInteger, Integer
+from sqlalchemy import String, Boolean, DateTime, ForeignKey, Numeric, text, Text, UniqueConstraint, BigInteger, Integer, Float
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 from sqlalchemy.dialects.postgresql import UUID as PG_UUID, JSONB
 from sqlalchemy.sql import func
@@ -14,10 +14,10 @@ class AssetCatalog(Base):
     __tablename__ = "vehicle_catalog"
     __table_args__ = (
         UniqueConstraint('make', 'model', 'year_from', 'fuel_type', name='uix_vehicle_catalog_full'),
-        {"schema": "data"}
+        {"schema": "vehicle"}
     )
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
-    master_definition_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("data.vehicle_model_definitions.id"))
+    master_definition_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("vehicle.vehicle_model_definitions.id"))
     
     make: Mapped[str] = mapped_column(String, index=True, nullable=False)
     model: Mapped[str] = mapped_column(String, index=True, nullable=False)
@@ -36,7 +36,7 @@ class AssetCatalog(Base):
 class Asset(Base):
     """ A fizikai eszköz (Digital Twin) - Minden adat itt fut össze. """
     __tablename__ = "assets"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "vehicle"}
 
     id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
     vin: Mapped[str] = mapped_column(String(17), unique=True, index=True, nullable=False)
@@ -54,14 +54,14 @@ class Asset(Base):
     price: Mapped[Optional[float]] = mapped_column(Numeric(15, 2))
     currency: Mapped[str] = mapped_column(String(3), default="EUR")
     
-    catalog_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("data.vehicle_catalog.id"))
-    current_organization_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("data.organizations.id"))
+    catalog_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("vehicle.vehicle_catalog.id"))
+    current_organization_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("fleet.organizations.id"))
     
     # Identity kapcsolatok
     owner_person_id: Mapped[Optional[int]] = mapped_column(BigInteger, ForeignKey("identity.persons.id"))
-    owner_org_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("data.organizations.id"))
+    owner_org_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("fleet.organizations.id"))
     operator_person_id: Mapped[Optional[int]] = mapped_column(BigInteger, ForeignKey("identity.persons.id"))
-    operator_org_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("data.organizations.id"))
+    operator_org_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("fleet.organizations.id"))
 
     status: Mapped[str] = mapped_column(String(20), default="active")
     individual_equipment: Mapped[dict] = mapped_column(JSONB, server_default=text("'{}'::jsonb"))
@@ -83,9 +83,9 @@ class Asset(Base):
 class AssetFinancials(Base):
     """ I. Beszerzés és IV. Értékcsökkenés (Amortizáció). """
     __tablename__ = "asset_financials"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "vehicle"}
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("data.assets.id"), unique=True)
+    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("vehicle.assets.id"), unique=True)
     
     purchase_price_net: Mapped[float] = mapped_column(Numeric(18, 2))
     purchase_price_gross: Mapped[float] = mapped_column(Numeric(18, 2))
@@ -99,10 +99,10 @@ class AssetFinancials(Base):
 class AssetCost(Base):
     """ II. Üzemeltetés és TCO kimutatás. """
     __tablename__ = "asset_costs"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "vehicle"}
     id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("data.assets.id"), nullable=False)
-    organization_id: Mapped[int] = mapped_column(Integer, ForeignKey("data.organizations.id"), nullable=False)
+    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("vehicle.assets.id"), nullable=False)
+    organization_id: Mapped[int] = mapped_column(Integer, ForeignKey("fleet.organizations.id"), nullable=False)
     
     cost_category: Mapped[str] = mapped_column(String(50), index=True) 
     amount_net: Mapped[float] = mapped_column(Numeric(18, 2), nullable=False)
@@ -117,15 +117,28 @@ class AssetCost(Base):
 class VehicleLogbook(Base):
     """ Útnyilvántartás (NAV, Kiküldetés, Munkábajárás). """
     __tablename__ = "vehicle_logbook"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "vehicle"}
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("data.assets.id"), nullable=False)
+    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("vehicle.assets.id"), nullable=False)
     driver_id: Mapped[int] = mapped_column(Integer, ForeignKey("identity.users.id"), nullable=False)
     
-    trip_type: Mapped[str] = mapped_column(String(30), index=True) 
+    trip_type: Mapped[str] = mapped_column(String(30), index=True)
     is_reimbursable: Mapped[bool] = mapped_column(Boolean, default=False)
     start_mileage: Mapped[int] = mapped_column(Integer)
     end_mileage: Mapped[Optional[int]] = mapped_column(Integer)
+    distance_km: Mapped[Optional[float]] = mapped_column(Numeric(10, 2), nullable=True)
+    
+    # GPS koordináták
+    start_lat: Mapped[Optional[float]] = mapped_column(Numeric(10, 6), nullable=True)
+    start_lng: Mapped[Optional[float]] = mapped_column(Numeric(10, 6), nullable=True)
+    end_lat: Mapped[Optional[float]] = mapped_column(Numeric(10, 6), nullable=True)
+    end_lng: Mapped[Optional[float]] = mapped_column(Numeric(10, 6), nullable=True)
+    gps_calculated_distance: Mapped[Optional[float]] = mapped_column(Numeric(10, 2), nullable=True)
+    
+    # OBDII és telemetria
+    obd_verified: Mapped[bool] = mapped_column(Boolean, default=False)
+    max_acceleration: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
+    average_speed: Mapped[Optional[float]] = mapped_column(Float, nullable=True)
     
     asset: Mapped["Asset"] = relationship("Asset", back_populates="logbook")
     driver: Mapped["User"] = relationship("User")
@@ -133,9 +146,9 @@ class VehicleLogbook(Base):
 class AssetInspection(Base):
     """ Napi ellenőrző lista és Biztonsági check. """
     __tablename__ = "asset_inspections"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "vehicle"}
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("data.assets.id"), nullable=False)
+    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("vehicle.assets.id"), nullable=False)
     inspector_id: Mapped[int] = mapped_column(Integer, ForeignKey("identity.users.id"), nullable=False)
     
     timestamp: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
@@ -148,9 +161,9 @@ class AssetInspection(Base):
 class AssetReview(Base):
     """ Jármű értékelések és visszajelzések. """
     __tablename__ = "asset_reviews"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "vehicle"}
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("data.assets.id"), nullable=False)
+    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("vehicle.assets.id"), nullable=False)
     user_id: Mapped[int] = mapped_column(Integer, ForeignKey("identity.users.id"), nullable=False)
     
     overall_rating: Mapped[Optional[int]] = mapped_column(Integer) # 1-5 csillag
@@ -163,9 +176,9 @@ class AssetReview(Base):
 class VehicleOwnership(Base):
     """ Tulajdonosváltások története. """
     __tablename__ = "vehicle_ownership_history"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "vehicle"}
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("data.assets.id"), nullable=False)
+    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("vehicle.assets.id"), nullable=False)
     user_id: Mapped[int] = mapped_column(Integer, ForeignKey("identity.users.id"), nullable=False)
     
     acquired_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
@@ -177,19 +190,19 @@ class VehicleOwnership(Base):
 
 class AssetTelemetry(Base):
     __tablename__ = "asset_telemetry"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "vehicle"}
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("data.assets.id"), unique=True)
+    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("vehicle.assets.id"), unique=True)
     current_mileage: Mapped[int] = mapped_column(Integer, default=0)
     asset: Mapped["Asset"] = relationship("Asset", back_populates="telemetry")
 
 class AssetAssignment(Base):
     """ Eszköz-Szervezet összerendelés. """
     __tablename__ = "asset_assignments"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "fleet"}
     id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("data.assets.id"), nullable=False)
-    organization_id: Mapped[int] = mapped_column(Integer, ForeignKey("data.organizations.id"), nullable=False)
+    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("vehicle.assets.id"), nullable=False)
+    organization_id: Mapped[int] = mapped_column(Integer, ForeignKey("fleet.organizations.id"), nullable=False)
     status: Mapped[str] = mapped_column(String(30), default="active")
     
     asset: Mapped["Asset"] = relationship("Asset", back_populates="assignments")
@@ -198,15 +211,15 @@ class AssetAssignment(Base):
 class AssetEvent(Base):
     """ Szerviz, baleset és egyéb jelentős események. """
     __tablename__ = "asset_events"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "vehicle"}
     id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("data.assets.id"), nullable=False)
+    asset_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("vehicle.assets.id"), nullable=False)
     event_type: Mapped[str] = mapped_column(String(50), nullable=False)
     asset: Mapped["Asset"] = relationship("Asset", back_populates="events")
 
 class ExchangeRate(Base):
     __tablename__ = "exchange_rates"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "finance"}
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     rate: Mapped[float] = mapped_column(Numeric(18, 6), nullable=False)
 
@@ -216,7 +229,9 @@ class CatalogDiscovery(Base):
     __table_args__ = (
         # KIBŐVÍTETT EGYEDISÉGI SZABÁLY: Márka + Modell + Osztály + Piac + Évjárat
         UniqueConstraint('make', 'model', 'vehicle_class', 'market', 'model_year', name='_make_model_market_year_uc'),
-        {"schema": "data"}
+        # Alapvető egyediség: make + model + vehicle_class (piac és évjárat nélkül)
+        UniqueConstraint('make', 'model', 'vehicle_class', name='uq_make_model_class'),
+        {"schema": "vehicle"}
     )
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     make: Mapped[str] = mapped_column(String(100), nullable=False, index=True)

backend/app/models/audit.py

@@ -12,6 +12,7 @@ from app.database import Base
 class SecurityAuditLog(Base):
     """ Kiemelt biztonsági események és a 4-szem elv naplózása. """
     __tablename__ = "security_audit_logs"
+    __table_args__ = {"schema": "audit"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     action: Mapped[Optional[str]] = mapped_column(String(50)) # 'ROLE_CHANGE', 'MANUAL_CREDIT_ADJUST'
@@ -28,6 +29,7 @@ class SecurityAuditLog(Base):
 class OperationalLog(Base):
     """ Felhasználói szintű napi üzemi események (Audit Trail). """
     __tablename__ = "operational_logs"
+    __table_args__ = {"schema": "audit"}
     
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     user_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("identity.users.id", ondelete="SET NULL"))
@@ -41,6 +43,7 @@ class OperationalLog(Base):
 class ProcessLog(Base):
     """ Robotok és háttérfolyamatok futási naplója (A reggeli jelentésekhez). """
     __tablename__ = "process_logs"
+    __table_args__ = {"schema": "audit"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     process_name: Mapped[str] = mapped_column(String(100), index=True) # 'Master-Enricher'
@@ -64,9 +67,18 @@ class WalletType(str, enum.Enum):
     VOUCHER = "VOUCHER"
 
 
+class LedgerStatus(str, enum.Enum):
+    PENDING = "PENDING"
+    SUCCESS = "SUCCESS"
+    FAILED = "FAILED"
+    REFUNDED = "REFUNDED"
+    REFUND = "REFUND"
+
+
 class FinancialLedger(Base):
     """ Minden pénz- és kreditmozgás központi naplója. Billing Engine alapja. """
     __tablename__ = "financial_ledger"
+    __table_args__ = {"schema": "audit"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     user_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("identity.users.id"))
@@ -87,6 +99,17 @@ class FinancialLedger(Base):
     wallet_type: Mapped[Optional[WalletType]] = mapped_column(
         PG_ENUM(WalletType, name="wallet_type", schema="audit")
     )
+    # Economy 1: számlázási mezők
+    issuer_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("finance.issuers.id"), nullable=True)
+    invoice_status: Mapped[Optional[str]] = mapped_column(String(50), default="PENDING")
+    tax_amount: Mapped[Optional[float]] = mapped_column(Numeric(18, 4))
+    gross_amount: Mapped[Optional[float]] = mapped_column(Numeric(18, 4))
+    net_amount: Mapped[Optional[float]] = mapped_column(Numeric(18, 4))
     transaction_id: Mapped[uuid.UUID] = mapped_column(
         PG_UUID(as_uuid=True), default=uuid.uuid4, nullable=False, index=True
+    )
+    status: Mapped[LedgerStatus] = mapped_column(
+        PG_ENUM(LedgerStatus, name="ledger_status", schema="audit"),
+        default=LedgerStatus.SUCCESS,
+        nullable=False
     )

backend/app/models/core_logic.py

@@ -15,7 +15,7 @@ class SubscriptionTier(Base):
     A csomagok határozzák meg a korlátokat (pl. max járműszám).
     """
     __tablename__ = "subscription_tiers"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "system"}
     
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     name: Mapped[str] = mapped_column(String, unique=True, index=True) # pl. 'premium'
@@ -27,15 +27,15 @@ class OrganizationSubscription(Base):
     Szervezetek aktuális előfizetései és azok érvényessége. 
     """
     __tablename__ = "org_subscriptions"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "finance"}
     
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     
-    # Kapcsolat a szervezettel (data séma)
-    org_id: Mapped[int] = mapped_column(Integer, ForeignKey("data.organizations.id"), nullable=False)
+    # Kapcsolat a szervezettel (fleet séma)
+    org_id: Mapped[int] = mapped_column(Integer, ForeignKey("fleet.organizations.id"), nullable=False)
     
-    # Kapcsolat a csomaggal (data séma)
-    tier_id: Mapped[int] = mapped_column(Integer, ForeignKey("data.subscription_tiers.id"), nullable=False)
+    # Kapcsolat a csomaggal (system séma)
+    tier_id: Mapped[int] = mapped_column(Integer, ForeignKey("system.subscription_tiers.id"), nullable=False)
     
     valid_from: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
     valid_until: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), nullable=True)
@@ -46,12 +46,12 @@ class CreditTransaction(Base):
     Kreditnapló (Pontok, kreditek vagy virtuális egyenleg követése). 
     """
     __tablename__ = "credit_logs"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "finance"}
     
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     
-    # Kapcsolat a szervezettel (data séma)
-    org_id: Mapped[int] = mapped_column(Integer, ForeignKey("data.organizations.id"), nullable=False)
+    # Kapcsolat a szervezettel (fleet séma)
+    org_id: Mapped[int] = mapped_column(Integer, ForeignKey("fleet.organizations.id"), nullable=False)
     
     amount: Mapped[float] = mapped_column(Numeric(10, 2), nullable=False)
     description: Mapped[Optional[str]] = mapped_column(String)
@@ -62,12 +62,12 @@ class ServiceSpecialty(Base):
     Hierarchikus fa struktúra a szerviz szolgáltatásokhoz (pl. Motor -> Futómű). 
     """
     __tablename__ = "service_specialties"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "marketplace"}
     
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     
     # Önmagára mutató idegen kulcs a hierarchiához
-    parent_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("data.service_specialties.id"))
+    parent_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("marketplace.service_specialties.id"))
     
     name: Mapped[str] = mapped_column(String, nullable=False)
     slug: Mapped[str] = mapped_column(String, unique=True, index=True)

backend/app/models/document.py

@@ -11,7 +11,7 @@ from app.db.base_class import Base
 class Document(Base):
     """ NAS alapú dokumentumtár metaadatai. """
     __tablename__ = "documents"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "system"}
 
     id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
     parent_type: Mapped[str] = mapped_column(String(20)) # 'organization' vagy 'asset'

backend/app/models/finance.py

@@ -0,0 +1,72 @@
+# /opt/docker/dev/service_finder/backend/app/models/finance.py
+"""
+Finance modellek: Issuer (Kibocsátó) és FinancialLedger (Pénzügyi főkönyv) bővítése.
+"""
+
+import enum
+import uuid
+from datetime import datetime
+from typing import Any, Optional
+from sqlalchemy import String, DateTime, JSON, ForeignKey, Numeric, Boolean, Integer, text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.dialects.postgresql import UUID as PG_UUID, ENUM as PG_ENUM
+from sqlalchemy.sql import func
+
+from app.database import Base
+
+
+class IssuerType(str, enum.Enum):
+    """Kibocsátó típusok (jogi forma)."""
+    KFT = "KFT"
+    EV = "EV"
+    BT = "BT"
+    ZRT = "ZRT"
+    OTHER = "OTHER"
+
+
+class Issuer(Base):
+    """
+    Kibocsátó (számlakibocsátó) entitás.
+    
+    A rendszerben a számlákat kibocsátó jogi személyek vagy vállalkozások.
+    Például: KFT, EV, stb. A revenue_limit meghatározza az adóhatár összegét.
+    """
+    __tablename__ = "issuers"
+    __table_args__ = {"schema": "finance"}
+    
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    
+    # Név és adószám
+    name: Mapped[str] = mapped_column(String(255), nullable=False, index=True)
+    tax_id: Mapped[Optional[str]] = mapped_column(String(50), unique=True, index=True)
+    
+    # Típus
+    type: Mapped[IssuerType] = mapped_column(
+        PG_ENUM(IssuerType, name="issuer_type", schema="finance"),
+        default=IssuerType.OTHER,
+        nullable=False
+    )
+    
+    # Bevételi limit (pl. KATA határ)
+    revenue_limit: Mapped[float] = mapped_column(Numeric(18, 4), default=19500000.0)
+    current_revenue: Mapped[float] = mapped_column(Numeric(18, 4), default=0.0)
+    
+    # Aktív-e
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True)
+    
+    # API konfiguráció (pl. számlázó rendszer integráció)
+    api_config: Mapped[Any] = mapped_column(JSON, server_default=text("'{}'::jsonb"))
+    
+    # Időbélyegek
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+    
+    def __repr__(self) -> str:
+        return f"<Issuer {self.id}: {self.name} ({self.type})>"
+
+
+# Import FinancialLedger from audit module? We'll keep it separate.
+# The FinancialLedger class remains in audit.py, but we add fields there.
+# For completeness, we could also define it here, but to avoid duplication,
+# we'll just import it if needed.
+# Instead, we'll add a relationship from FinancialLedger to Issuer in audit.py.

backend/app/models/gamification.py

@@ -12,7 +12,7 @@ if TYPE_CHECKING:
 
 class PointRule(Base):
     __tablename__ = "point_rules"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "system"}
     
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     action_key: Mapped[str] = mapped_column(String, unique=True, index=True)
@@ -22,7 +22,7 @@ class PointRule(Base):
 
 class LevelConfig(Base):
     __tablename__ = "level_configs"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "system"}
     
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     level_number: Mapped[int] = mapped_column(Integer, unique=True)
@@ -31,7 +31,7 @@ class LevelConfig(Base):
 
 class PointsLedger(Base):
     __tablename__ = "points_ledger"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "system"}
     
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     
@@ -47,7 +47,7 @@ class PointsLedger(Base):
 
 class UserStats(Base):
     __tablename__ = "user_stats"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "system"}
 
     # MB 2.0: User az identity sémában lakik!
     user_id: Mapped[int] = mapped_column(Integer, ForeignKey("identity.users.id"), primary_key=True)
@@ -64,7 +64,7 @@ class UserStats(Base):
 
 class Badge(Base):
     __tablename__ = "badges"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "system"}
     
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     name: Mapped[str] = mapped_column(String, unique=True)
@@ -73,13 +73,13 @@ class Badge(Base):
 
 class UserBadge(Base):
     __tablename__ = "user_badges"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "system"}
     
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     
     # MB 2.0: User az identity sémában lakik!
     user_id: Mapped[int] = mapped_column(Integer, ForeignKey("identity.users.id"))
-    badge_id: Mapped[int] = mapped_column(Integer, ForeignKey("data.badges.id"))
+    badge_id: Mapped[int] = mapped_column(Integer, ForeignKey("system.badges.id"))
     
     earned_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
     

backend/app/models/history.py

@@ -21,7 +21,7 @@ class LogSeverity(str, enum.Enum):
 class AuditLog(Base):
     """ Rendszerszintű műveletnapló. """
     __tablename__ = "audit_logs"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "audit"}
     
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     
@@ -29,7 +29,7 @@ class AuditLog(Base):
     user_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("identity.users.id"))
     
     severity: Mapped[LogSeverity] = mapped_column(
-        PG_ENUM(LogSeverity, name="log_severity", schema="data"),
+        PG_ENUM(LogSeverity, name="log_severity", schema="audit"),
         default=LogSeverity.info
     )
     

backend/app/models/identity.py

@@ -1,4 +1,3 @@
-# /opt/docker/dev/service_finder/backend/app/models/identity.py
 from __future__ import annotations
 import uuid
 import enum
@@ -16,6 +15,8 @@ if TYPE_CHECKING:
     from .organization import Organization, OrganizationMember
     from .asset import VehicleOwnership
     from .gamification import UserStats
+    from .payment import PaymentIntent, WithdrawalRequest
+    from .social import ServiceReview, SocialAccount
 
 class UserRole(str, enum.Enum):
     superadmin = "superadmin"
@@ -40,11 +41,10 @@ class Person(Base):
     id: Mapped[int] = mapped_column(BigInteger, primary_key=True, index=True)
     id_uuid: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), default=uuid.uuid4, unique=True, nullable=False)
     
-    # A lakcím a 'data' sémában marad
-    address_id: Mapped[Optional[uuid.UUID]] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("data.addresses.id"))
+    # A lakcím a 'system' sémában van
+    address_id: Mapped[Optional[uuid.UUID]] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("system.addresses.id"))
     
     # Kritikus azonosító: Név + Anyja neve + Szül.idő hash-elve.
-    # Ezzel ismerjük fel a személyt akkor is, ha új User accountot hoz létre.
     identity_hash: Mapped[Optional[str]] = mapped_column(String(64), unique=True, index=True)
     
     last_name: Mapped[str] = mapped_column(String, nullable=False)
@@ -73,9 +73,6 @@ class Person(Base):
     # --- KAPCSOLATOK ---
     users: Mapped[List["User"]] = relationship("User", back_populates="person")
     memberships: Mapped[List["OrganizationMember"]] = relationship("OrganizationMember", back_populates="person")
-    
-    # MB 2.0 KIEGÉSZÍTÉS: A személy által birtokolt üzleti entitások (Cégek/Szolgáltatók)
-    # Ez a lista megmarad akkor is, ha az Organization deaktiválódik.
     owned_business_entities: Mapped[List["Organization"]] = relationship("Organization", back_populates="legal_owner")
 
 class User(Base):
@@ -117,33 +114,24 @@ class User(Base):
     
     created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
     
-    # Kapcsolatok
+    # --- KAPCSOLATOK ---
     person: Mapped[Optional["Person"]] = relationship("Person", back_populates="users")
     wallet: Mapped[Optional["Wallet"]] = relationship("Wallet", back_populates="user", uselist=False)
+    
+    # JAVÍTÁS: Ez a sor KELL az OCR robot és a Trust Engine működéséhez
+    trust_profile: Mapped[Optional["UserTrustProfile"]] = relationship("UserTrustProfile", back_populates="user", uselist=False, cascade="all, delete-orphan")
+    
     social_accounts: Mapped[List["SocialAccount"]] = relationship("SocialAccount", back_populates="user", cascade="all, delete-orphan")
     owned_organizations: Mapped[List["Organization"]] = relationship("Organization", back_populates="owner")
     stats: Mapped[Optional["UserStats"]] = relationship("UserStats", back_populates="user", uselist=False, cascade="all, delete-orphan")
     ownership_history: Mapped[List["VehicleOwnership"]] = relationship("VehicleOwnership", back_populates="user")
     
-    # PaymentIntent kapcsolatok
-    payment_intents_as_payer: Mapped[List["PaymentIntent"]] = relationship(
-        "PaymentIntent",
-        foreign_keys="[PaymentIntent.payer_id]",
-        back_populates="payer"
-    )
+    # Pénzügyi és egyéb kapcsolatok
     withdrawal_requests: Mapped[List["WithdrawalRequest"]] = relationship("WithdrawalRequest", foreign_keys="[WithdrawalRequest.user_id]", back_populates="user", cascade="all, delete-orphan")
-    payment_intents_as_beneficiary: Mapped[List["PaymentIntent"]] = relationship(
-        "PaymentIntent",
-        foreign_keys="[PaymentIntent.beneficiary_id]",
-        back_populates="beneficiary"
-    )
-
-    @property
-    def tier_name(self) -> str:
-        """Kompatibilitási mező a keresőhöz: a 'FREE' -> 'free' konverzióhoz"""
-        return (self.subscription_plan or "free").lower()
+    service_reviews: Mapped[List["ServiceReview"]] = relationship("ServiceReview", back_populates="user", cascade="all, delete-orphan")
 
 class Wallet(Base):
+    """ Felhasználói pénztárca. """
     __tablename__ = "wallets"
     __table_args__ = {"schema": "identity"}
     
@@ -159,6 +147,7 @@ class Wallet(Base):
     active_vouchers: Mapped[List["ActiveVoucher"]] = relationship("ActiveVoucher", back_populates="wallet", cascade="all, delete-orphan")
 
 class VerificationToken(Base):
+    """ E-mail és egyéb verifikációs tokenek. """
     __tablename__ = "verification_tokens"
     __table_args__ = {"schema": "identity"}
     
@@ -171,6 +160,7 @@ class VerificationToken(Base):
     is_used: Mapped[bool] = mapped_column(Boolean, default=False)
 
 class SocialAccount(Base):
+    """ Közösségi bejelentkezési adatok (Google, Facebook, stb). """
     __tablename__ = "social_accounts"
     __table_args__ = (
         UniqueConstraint('provider', 'social_id', name='uix_social_provider_id'), 
@@ -187,9 +177,8 @@ class SocialAccount(Base):
     
     user: Mapped["User"] = relationship("User", back_populates="social_accounts")
 
-
 class ActiveVoucher(Base):
-    """Aktív, le nem járt voucher-ek tárolása FIFO elv szerint."""
+    """ Aktív, le nem járt voucher-ek tárolása FIFO elv szerint. """
     __tablename__ = "active_vouchers"
     __table_args__ = {"schema": "identity"}
     
@@ -200,5 +189,27 @@ class ActiveVoucher(Base):
     expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
     created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
     
-    # Kapcsolatok
-    wallet: Mapped["Wallet"] = relationship("Wallet", back_populates="active_vouchers")
+    wallet: Mapped["Wallet"] = relationship("Wallet", back_populates="active_vouchers")
+
+class UserTrustProfile(Base):
+    """ Gondos Gazda Index (Trust Score) tárolása. """
+    __tablename__ = "user_trust_profiles"
+    __table_args__ = {"schema": "identity"}
+    
+    user_id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey("identity.users.id", ondelete="CASCADE"),
+        primary_key=True,
+        index=True
+    )
+    trust_score: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
+    maintenance_score: Mapped[float] = mapped_column(Numeric(5, 2), default=0.0, nullable=False)
+    quality_score: Mapped[float] = mapped_column(Numeric(5, 2), default=0.0, nullable=False)
+    preventive_score: Mapped[float] = mapped_column(Numeric(5, 2), default=0.0, nullable=False)
+    last_calculated: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        nullable=False
+    )
+    
+    user: Mapped["User"] = relationship("User", back_populates="trust_profile", uselist=False)

backend/app/models/identity_1.0.py

@@ -0,0 +1,234 @@
+# /opt/docker/dev/service_finder/backend/app/models/identity.py
+from __future__ import annotations
+import uuid
+import enum
+from datetime import datetime
+from typing import Any, List, Optional, TYPE_CHECKING
+from sqlalchemy import String, Boolean, DateTime, ForeignKey, JSON, Numeric, text, Integer, BigInteger, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.dialects.postgresql import UUID as PG_UUID, ENUM as PG_ENUM
+from sqlalchemy.sql import func
+
+# MB 2.0: Központi aszinkron adatbázis motorból húzzuk be a Base-t
+from app.database import Base
+
+if TYPE_CHECKING:
+    from .organization import Organization, OrganizationMember
+    from .asset import VehicleOwnership
+    from .gamification import UserStats
+
+class UserRole(str, enum.Enum):
+    superadmin = "superadmin"
+    admin = "admin"
+    region_admin = "region_admin"
+    country_admin = "country_admin"
+    moderator = "moderator"
+    sales_agent = "sales_agent"
+    user = "user"
+    service_owner = "service_owner"
+    fleet_manager = "fleet_manager"
+    driver = "driver"
+
+class Person(Base):
+    """
+    Természetes személy identitása. A DNS szint.
+    Minden identitás adat az 'identity' sémába kerül.
+    """
+    __tablename__ = "persons"
+    __table_args__ = {"schema": "identity"}
+    
+    id: Mapped[int] = mapped_column(BigInteger, primary_key=True, index=True)
+    id_uuid: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), default=uuid.uuid4, unique=True, nullable=False)
+    
+    # A lakcím a 'data' sémában marad
+    address_id: Mapped[Optional[uuid.UUID]] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("system.addresses.id"))
+    
+    # Kritikus azonosító: Név + Anyja neve + Szül.idő hash-elve.
+    # Ezzel ismerjük fel a személyt akkor is, ha új User accountot hoz létre.
+    identity_hash: Mapped[Optional[str]] = mapped_column(String(64), unique=True, index=True)
+    
+    last_name: Mapped[str] = mapped_column(String, nullable=False)
+    first_name: Mapped[str] = mapped_column(String, nullable=False)
+    phone: Mapped[Optional[str]] = mapped_column(String)
+    
+    mothers_last_name: Mapped[Optional[str]] = mapped_column(String)
+    mothers_first_name: Mapped[Optional[str]] = mapped_column(String)
+    birth_place: Mapped[Optional[str]] = mapped_column(String)
+    birth_date: Mapped[Optional[datetime]] = mapped_column(DateTime)
+    
+    identity_docs: Mapped[Any] = mapped_column(JSON, server_default=text("'{}'::jsonb"))
+    ice_contact: Mapped[Any] = mapped_column(JSON, server_default=text("'{}'::jsonb"))
+    
+    lifetime_xp: Mapped[int] = mapped_column(BigInteger, server_default=text("0"))
+    penalty_points: Mapped[int] = mapped_column(Integer, server_default=text("0"))
+    social_reputation: Mapped[float] = mapped_column(Numeric(3, 2), server_default=text("1.00"))
+    
+    is_sales_agent: Mapped[bool] = mapped_column(Boolean, server_default=text("false"))
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+    is_ghost: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+    
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    updated_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), onupdate=func.now())
+    
+    # --- KAPCSOLATOK ---
+    users: Mapped[List["User"]] = relationship("User", back_populates="person")
+    memberships: Mapped[List["OrganizationMember"]] = relationship("OrganizationMember", back_populates="person")
+    
+    # MB 2.0 KIEGÉSZÍTÉS: A személy által birtokolt üzleti entitások (Cégek/Szolgáltatók)
+    # Ez a lista megmarad akkor is, ha az Organization deaktiválódik.
+    owned_business_entities: Mapped[List["Organization"]] = relationship("Organization", back_populates="legal_owner")
+
+class User(Base):
+    """ Login entitás. Bármikor törölhető (GDPR), de Person-höz kötött. """
+    __tablename__ = "users"
+    __table_args__ = {"schema": "identity"}
+    
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    email: Mapped[str] = mapped_column(String, unique=True, index=True, nullable=False)
+    hashed_password: Mapped[Optional[str]] = mapped_column(String)
+    
+    role: Mapped[UserRole] = mapped_column(
+        PG_ENUM(UserRole, name="userrole", schema="identity"), 
+        default=UserRole.user
+    )
+    
+    person_id: Mapped[Optional[int]] = mapped_column(BigInteger, ForeignKey("identity.persons.id"))
+    trust_profile: Mapped[Optional["UserTrustProfile"]] = relationship("UserTrustProfile", back_populates="user", uselist=False, cascade="all, delete-orphan")
+    subscription_plan: Mapped[str] = mapped_column(String(30), server_default=text("'FREE'"))
+    subscription_expires_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True))
+    is_vip: Mapped[bool] = mapped_column(Boolean, server_default=text("false"))
+    
+    referral_code: Mapped[Optional[str]] = mapped_column(String(20), unique=True)
+    
+    referred_by_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("identity.users.id"))
+    current_sales_agent_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("identity.users.id"))
+
+    is_active: Mapped[bool] = mapped_column(Boolean, default=False)
+    is_deleted: Mapped[bool] = mapped_column(Boolean, default=False)
+    folder_slug: Mapped[Optional[str]] = mapped_column(String(12), unique=True, index=True)
+    
+    preferred_language: Mapped[str] = mapped_column(String(5), server_default="hu")
+    region_code: Mapped[str] = mapped_column(String(5), server_default="HU")
+    preferred_currency: Mapped[str] = mapped_column(String(3), server_default="HUF")
+    
+    scope_level: Mapped[str] = mapped_column(String(30), server_default="individual")
+    scope_id: Mapped[Optional[str]] = mapped_column(String(50))
+    custom_permissions: Mapped[Any] = mapped_column(JSON, server_default=text("'{}'::jsonb"))
+    
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    
+    # Kapcsolatok
+    person: Mapped[Optional["Person"]] = relationship("Person", back_populates="users")
+    wallet: Mapped[Optional["Wallet"]] = relationship("Wallet", back_populates="user", uselist=False)
+    social_accounts: Mapped[List["SocialAccount"]] = relationship("SocialAccount", back_populates="user", cascade="all, delete-orphan")
+    owned_organizations: Mapped[List["Organization"]] = relationship("Organization", back_populates="owner")
+    stats: Mapped[Optional["UserStats"]] = relationship("UserStats", back_populates="user", uselist=False, cascade="all, delete-orphan")
+    ownership_history: Mapped[List["VehicleOwnership"]] = relationship("VehicleOwnership", back_populates="user")
+    
+    # PaymentIntent kapcsolatok
+    payment_intents_as_payer: Mapped[List["PaymentIntent"]] = relationship(
+        "PaymentIntent",
+        foreign_keys="[PaymentIntent.payer_id]",
+        back_populates="payer"
+    )
+    withdrawal_requests: Mapped[List["WithdrawalRequest"]] = relationship("WithdrawalRequest", foreign_keys="[WithdrawalRequest.user_id]", back_populates="user", cascade="all, delete-orphan")
+    payment_intents_as_beneficiary: Mapped[List["PaymentIntent"]] = relationship(
+        "PaymentIntent",
+        foreign_keys="[PaymentIntent.beneficiary_id]",
+        back_populates="beneficiary"
+    )
+    # Service reviews
+    service_reviews: Mapped[List["ServiceReview"]] = relationship("ServiceReview", back_populates="user", cascade="all, delete-orphan")
+
+    @property
+    def tier_name(self) -> str:
+        """Kompatibilitási mező a keresőhöz: a 'FREE' -> 'free' konverzióhoz"""
+        return (self.subscription_plan or "free").lower()
+
+class Wallet(Base):
+    __tablename__ = "wallets"
+    __table_args__ = {"schema": "identity"}
+    
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    user_id: Mapped[int] = mapped_column(Integer, ForeignKey("identity.users.id"), unique=True)
+    
+    earned_credits: Mapped[float] = mapped_column(Numeric(18, 4), server_default=text("0"))
+    purchased_credits: Mapped[float] = mapped_column(Numeric(18, 4), server_default=text("0"))
+    service_coins: Mapped[float] = mapped_column(Numeric(18, 4), server_default=text("0"))
+    
+    currency: Mapped[str] = mapped_column(String(3), default="HUF")
+    user: Mapped["User"] = relationship("User", back_populates="wallet")
+    active_vouchers: Mapped[List["ActiveVoucher"]] = relationship("ActiveVoucher", back_populates="wallet", cascade="all, delete-orphan")
+
+class VerificationToken(Base):
+    __tablename__ = "verification_tokens"
+    __table_args__ = {"schema": "identity"}
+    
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    token: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), default=uuid.uuid4, unique=True, nullable=False)
+    user_id: Mapped[int] = mapped_column(Integer, ForeignKey("identity.users.id", ondelete="CASCADE"), nullable=False)
+    token_type: Mapped[str] = mapped_column(String(20), nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+    is_used: Mapped[bool] = mapped_column(Boolean, default=False)
+
+class SocialAccount(Base):
+    __tablename__ = "social_accounts"
+    __table_args__ = (
+        UniqueConstraint('provider', 'social_id', name='uix_social_provider_id'), 
+        {"schema": "identity"}
+    )
+    
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    user_id: Mapped[int] = mapped_column(Integer, ForeignKey("identity.users.id", ondelete="CASCADE"), nullable=False)
+    provider: Mapped[str] = mapped_column(String(50), nullable=False)
+    social_id: Mapped[str] = mapped_column(String(255), nullable=False, index=True)
+    email: Mapped[str] = mapped_column(String(255), nullable=False)
+    extra_data: Mapped[Any] = mapped_column(JSON, server_default=text("'{}'::jsonb"))
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    
+    user: Mapped["User"] = relationship("User", back_populates="social_accounts")
+
+
+class ActiveVoucher(Base):
+    """Aktív, le nem járt voucher-ek tárolása FIFO elv szerint."""
+    __tablename__ = "active_vouchers"
+    __table_args__ = {"schema": "identity"}
+    
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    wallet_id: Mapped[int] = mapped_column(Integer, ForeignKey("identity.wallets.id", ondelete="CASCADE"), nullable=False)
+    amount: Mapped[float] = mapped_column(Numeric(18, 4), nullable=False)
+    original_amount: Mapped[float] = mapped_column(Numeric(18, 4), nullable=False)
+    expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    
+    # Kapcsolatok
+    wallet: Mapped["Wallet"] = relationship("Wallet", back_populates="active_vouchers")
+
+
+class UserTrustProfile(Base):
+    """
+    Gondos Gazda Index (Trust Score) tárolása felhasználónként.
+    A pontszámot a trust_engine számolja dinamikusan a SystemParameter-ek alapján.
+    """
+    __tablename__ = "user_trust_profiles"
+    __table_args__ = {"schema": "identity"}
+    
+    user_id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey("identity.users.id", ondelete="CASCADE"),
+        primary_key=True,
+        index=True
+    )
+    trust_score: Mapped[int] = mapped_column(Integer, default=0, nullable=False)  # 0-100 pont
+    maintenance_score: Mapped[float] = mapped_column(Numeric(5, 2), default=0.0, nullable=False)  # 0.0-1.0
+    quality_score: Mapped[float] = mapped_column(Numeric(5, 2), default=0.0, nullable=False)  # 0.0-1.0
+    preventive_score: Mapped[float] = mapped_column(Numeric(5, 2), default=0.0, nullable=False)  # 0.0-1.0
+    last_calculated: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        nullable=False
+    )
+    
+    # Kapcsolatok
+    user: Mapped["User"] = relationship("User", back_populates="trust_profile", uselist=False)

backend/app/models/legal.py

@@ -8,6 +8,7 @@ from app.db.base_class import Base
 
 class LegalDocument(Base):
     __tablename__ = "legal_documents"
+    __table_args__ = {"schema": "system"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     title: Mapped[Optional[str]] = mapped_column(String(255))
@@ -22,10 +23,11 @@ class LegalDocument(Base):
 
 class LegalAcceptance(Base):
     __tablename__ = "legal_acceptances"
+    __table_args__ = {"schema": "identity"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     user_id: Mapped[int] = mapped_column(Integer, ForeignKey("identity.users.id"))
-    document_id: Mapped[int] = mapped_column(Integer, ForeignKey("data.legal_documents.id"))
+    document_id: Mapped[int] = mapped_column(Integer, ForeignKey("system.legal_documents.id"))
     accepted_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
     ip_address: Mapped[Optional[str]] = mapped_column(String(45))
-    user_agent: Mapped[Optional[str]] = mapped_column(Text) 
+    user_agent: Mapped[Optional[str]] = mapped_column(Text)

backend/app/models/logistics.py

@@ -13,6 +13,7 @@ class LocationType(str, enum.Enum):
 
 class Location(Base):
     __tablename__ = "locations"
+    __table_args__ = {"schema": "fleet"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     name: Mapped[str] = mapped_column(String)
@@ -21,6 +22,6 @@ class Location(Base):
         nullable=False
     )
     
-    coordinates: Mapped[Optional[str]] = mapped_column(String) 
+    coordinates: Mapped[Optional[str]] = mapped_column(String)
     address_full: Mapped[Optional[str]] = mapped_column(String)
-    capacity: Mapped[Optional[int]] = mapped_column(Integer) 
+    capacity: Mapped[Optional[int]] = mapped_column(Integer)

backend/app/models/organization.py

@@ -35,7 +35,7 @@ class Organization(Base):
     a jármű-életút adatok megmaradnak az eredeti Person-höz kötve.
     """
     __tablename__ = "organizations"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "fleet"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     
@@ -60,7 +60,7 @@ class Organization(Base):
     lifecycle_index: Mapped[int] = mapped_column(Integer, default=1, server_default=text("1"))
 
     # --- 🏢 ALAPADATOK (MEGŐRIZVE) ---
-    address_id: Mapped[Optional[uuid.UUID]] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("data.addresses.id"))
+    address_id: Mapped[Optional[uuid.UUID]] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("system.addresses.id"))
 
     is_anonymized: Mapped[bool] = mapped_column(Boolean, default=False, server_default=text("false"))
     anonymized_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True))
@@ -85,7 +85,7 @@ class Organization(Base):
     reg_number: Mapped[Optional[str]] = mapped_column(String(50))
     
     org_type: Mapped[OrgType] = mapped_column(
-        PG_ENUM(OrgType, name="orgtype", schema="data"), 
+        PG_ENUM(OrgType, name="orgtype", schema="fleet"),
         default=OrgType.individual
     )
     
@@ -125,13 +125,16 @@ class Organization(Base):
     
     # Kapcsolat az örök személy rekordhoz
     legal_owner: Mapped[Optional["Person"]] = relationship("Person", back_populates="owned_business_entities")
+    
+    # Kapcsolat a jármű költségekhez (TCO rendszer)
+    vehicle_costs: Mapped[List["VehicleCost"]] = relationship("VehicleCost", back_populates="organization")
 
 class OrganizationFinancials(Base):
     __tablename__ = "organization_financials"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "fleet"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
-    organization_id: Mapped[int] = mapped_column(Integer, ForeignKey("data.organizations.id"), nullable=False)
+    organization_id: Mapped[int] = mapped_column(Integer, ForeignKey("fleet.organizations.id"), nullable=False)
     year: Mapped[int] = mapped_column(Integer, nullable=False)
     turnover: Mapped[Optional[float]] = mapped_column(Numeric(18, 2))
     profit: Mapped[Optional[float]] = mapped_column(Numeric(18, 2))
@@ -143,16 +146,16 @@ class OrganizationFinancials(Base):
 
 class OrganizationMember(Base):
     __tablename__ = "organization_members"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "fleet"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
-    organization_id: Mapped[int] = mapped_column(Integer, ForeignKey("data.organizations.id"), nullable=False)
+    organization_id: Mapped[int] = mapped_column(Integer, ForeignKey("fleet.organizations.id"), nullable=False)
     
     user_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("identity.users.id"))
     person_id: Mapped[Optional[int]] = mapped_column(BigInteger, ForeignKey("identity.persons.id")) 
     
     role: Mapped[OrgUserRole] = mapped_column(
-        PG_ENUM(OrgUserRole, name="orguserrole", schema="data"), 
+        PG_ENUM(OrgUserRole, name="orguserrole", schema="fleet"),
         default=OrgUserRole.DRIVER
     )
     permissions: Mapped[Any] = mapped_column(JSON, server_default=text("'{}'::jsonb"))
@@ -165,10 +168,10 @@ class OrganizationMember(Base):
 
 class OrganizationSalesAssignment(Base):
     __tablename__ = "org_sales_assignments"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "fleet"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    organization_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("data.organizations.id"))
+    organization_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("fleet.organizations.id"))
     agent_user_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("identity.users.id"))
     
     assigned_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
@@ -179,11 +182,11 @@ class Branch(Base):
     Telephely entitás. A fizikai helyszín, ahol a szolgáltatás vagy flotta-kezelés zajlik.
     """
     __tablename__ = "branches"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "fleet"}
 
     id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-    organization_id: Mapped[int] = mapped_column(Integer, ForeignKey("data.organizations.id"), nullable=False)
-    address_id: Mapped[Optional[uuid.UUID]] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("data.addresses.id"))
+    organization_id: Mapped[int] = mapped_column(Integer, ForeignKey("fleet.organizations.id"), nullable=False)
+    address_id: Mapped[Optional[uuid.UUID]] = mapped_column(PG_UUID(as_uuid=True), ForeignKey("system.addresses.id"))
     
     name: Mapped[str] = mapped_column(String(100), nullable=False)
     is_main: Mapped[bool] = mapped_column(Boolean, default=False)

backend/app/models/payment.py

@@ -41,7 +41,7 @@ class PaymentIntent(Base):
     - gross_amount: net_amount + handling_fee (Stripe-nak küldött összeg)
     """
     __tablename__ = "payment_intents"
-    __table_args__ = {"schema": "audit"}
+    __table_args__ = {"schema": "finance"}
     
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     
@@ -60,7 +60,7 @@ class PaymentIntent(Base):
     
     # Cél pénztárca típusa
     target_wallet_type: Mapped[WalletType] = mapped_column(
-        PG_ENUM(WalletType, name="wallet_type", schema="audit"),
+        PG_ENUM(WalletType, name="wallet_type", schema="finance"),
         nullable=False
     )
     
@@ -73,7 +73,7 @@ class PaymentIntent(Base):
     
     # Státusz
     status: Mapped[PaymentIntentStatus] = mapped_column(
-        PG_ENUM(PaymentIntentStatus, name="payment_intent_status", schema="audit"),
+        PG_ENUM(PaymentIntentStatus, name="payment_intent_status", schema="finance"),
         default=PaymentIntentStatus.PENDING,
         nullable=False,
         index=True
@@ -152,7 +152,7 @@ class WithdrawalRequest(Base):
     Ha 14 napon belül nem kerül jóváhagyásra, automatikusan REJECTED lesz és a pénz visszakerül a Earned zsebbe.
     """
     __tablename__ = "withdrawal_requests"
-    __table_args__ = {"schema": "audit"}
+    __table_args__ = {"schema": "finance"}
     
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     
@@ -166,13 +166,13 @@ class WithdrawalRequest(Base):
     
     # Kifizetési mód
     payout_method: Mapped[WithdrawalPayoutMethod] = mapped_column(
-        PG_ENUM(WithdrawalPayoutMethod, name="withdrawal_payout_method", schema="audit"),
+        PG_ENUM(WithdrawalPayoutMethod, name="withdrawal_payout_method", schema="finance"),
         nullable=False
     )
     
     # Státusz
     status: Mapped[WithdrawalRequestStatus] = mapped_column(
-        PG_ENUM(WithdrawalRequestStatus, name="withdrawal_request_status", schema="audit"),
+        PG_ENUM(WithdrawalRequestStatus, name="withdrawal_request_status", schema="finance"),
         default=WithdrawalRequestStatus.PENDING,
         nullable=False,
         index=True

backend/app/models/reference_data.py

@@ -5,7 +5,7 @@ from app.database import Base
 
 class ReferenceLookup(Base):
     __tablename__ = "reference_lookup"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "vehicle"}
 
     id = Column(Integer, primary_key=True, index=True)
     make = Column(String, nullable=False, index=True)
@@ -13,7 +13,7 @@ class ReferenceLookup(Base):
     year = Column(Integer, nullable=True, index=True)
     
     # Itt tároljuk az egységesített adatokat
-    specs = Column(JSONB, nullable=False) 
+    specs = Column(JSONB, nullable=False)
     
     source = Column(String, nullable=False) # pl: 'os-vehicle-db', 'wikidata'
     source_id = Column(String, nullable=True)

backend/app/models/registry.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""
+Central Model Registry for Service Finder
+
+Automatically discovers and imports all SQLAlchemy models from the models directory,
+ensuring Base.metadata is fully populated with tables, constraints, and indexes.
+
+Usage:
+    from app.models.registry import Base, get_all_models, ensure_models_loaded
+"""
+
+import importlib
+import os
+import sys
+from pathlib import Path
+from typing import Dict, List, Type
+
+from sqlalchemy.ext.declarative import DeclarativeMeta
+from sqlalchemy.orm import DeclarativeBase
+
+# Import the Base from database (circular dependency will be resolved later)
+# We'll define our own Base if needed, but better to reuse existing one.
+# We'll import after path setup.
+
+# Add backend to path if not already
+backend_dir = Path(__file__).parent.parent.parent
+if str(backend_dir) not in sys.path:
+    sys.path.insert(0, str(backend_dir))
+
+# Import Base from database (this will be the same Base used everywhere)
+from app.database import Base
+
+def discover_model_files() -> List[Path]:
+    """
+    Walk through models directory and collect all .py files except __init__.py and registry.py.
+    """
+    models_dir = Path(__file__).parent
+    model_files = []
+    for root, _, files in os.walk(models_dir):
+        for file in files:
+            if file.endswith('.py') and file not in ('__init__.py', 'registry.py'):
+                full_path = Path(root) / file
+                model_files.append(full_path)
+    return model_files
+
+def import_module_from_file(file_path: Path) -> str:
+    """
+    Import a Python module from its file path.
+    Returns the module name.
+    """
+    # Compute module name relative to backend/app
+    rel_path = file_path.relative_to(backend_dir)
+    module_name = str(rel_path).replace(os.sep, '.').replace('.py', '')
+    
+    try:
+        spec = importlib.util.spec_from_file_location(module_name, file_path)
+        if spec is None:
+            raise ImportError(f"Could not load spec for {module_name}")
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = module
+        spec.loader.exec_module(module)
+        return module_name
+    except Exception as e:
+        # Silently skip import errors (maybe due to missing dependencies)
+        # but log for debugging
+        print(f"⚠️  Could not import {module_name}: {e}", file=sys.stderr)
+        return None
+
+def load_all_models() -> List[str]:
+    """
+    Dynamically import all model files to populate Base.metadata.
+    Returns list of successfully imported module names.
+    """
+    model_files = discover_model_files()
+    imported = []
+    for file in model_files:
+        module_name = import_module_from_file(file)
+        if module_name:
+            imported.append(module_name)
+    # Also ensure the __init__.py is loaded (it imports many models manually)
+    try:
+        import app.models
+        imported.append('app.models')
+    except ImportError:
+        pass
+    print(f"✅ Registry loaded {len(imported)} model modules. Total tables in metadata: {len(Base.metadata.tables)}")
+    return imported
+
+def get_all_models() -> Dict[str, Type[DeclarativeMeta]]:
+    """
+    Return a mapping of class name to model class for all registered SQLAlchemy models.
+    This works only after models have been imported.
+    """
+    # This is a heuristic: find all subclasses of Base in loaded modules
+    from sqlalchemy.orm import DeclarativeBase
+    models = {}
+    for cls in Base.__subclasses__():
+        models[cls.__name__] = cls
+    # Also check deeper inheritance (if models inherit from other models that inherit from Base)
+    for module_name, module in sys.modules.items():
+        if module_name.startswith('app.models.'):
+            for attr_name in dir(module):
+                attr = getattr(module, attr_name)
+                if isinstance(attr, type) and issubclass(attr, Base) and attr is not Base:
+                    models[attr.__name__] = attr
+    return models
+
+def ensure_models_loaded():
+    """
+    Ensure that all models are loaded into Base.metadata.
+    This is idempotent and can be called multiple times.
+    """
+    if len(Base.metadata.tables) == 0:
+        load_all_models()
+    else:
+        # Already loaded
+        pass
+
+# Auto-load models when this module is imported (optional, but useful)
+# We'll make it explicit via a function call to avoid side effects.
+# Instead, we'll provide a function to trigger loading.
+
+# Export
+__all__ = ['Base', 'discover_model_files', 'load_all_models', 'get_all_models', 'ensure_models_loaded']

backend/app/models/service.py

@@ -16,12 +16,12 @@ class ServiceProfile(Base):
     __tablename__ = "service_profiles"
     __table_args__ = (
         Index('idx_service_fingerprint', 'fingerprint', unique=True),
-        {"schema": "data"}
+        {"schema": "marketplace"}
     )
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
-    organization_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("data.organizations.id"), unique=True)
-    parent_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("data.service_profiles.id"))
+    organization_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("fleet.organizations.id"), unique=True)
+    parent_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("marketplace.service_profiles.id"))
     
     fingerprint: Mapped[str] = mapped_column(String(255), index=True, nullable=False)
     location: Mapped[Any] = mapped_column(Geometry(geometry_type='POINT', srid=4326, spatial_index=False), index=True)
@@ -33,6 +33,15 @@ class ServiceProfile(Base):
     rating: Mapped[Optional[float]] = mapped_column(Float)
     user_ratings_total: Mapped[Optional[int]] = mapped_column(Integer)
     
+    # Aggregated verified review ratings (Social 3)
+    rating_verified_count: Mapped[Optional[int]] = mapped_column(Integer, server_default=text("0"))
+    rating_price_avg: Mapped[Optional[float]] = mapped_column(Float)
+    rating_quality_avg: Mapped[Optional[float]] = mapped_column(Float)
+    rating_time_avg: Mapped[Optional[float]] = mapped_column(Float)
+    rating_communication_avg: Mapped[Optional[float]] = mapped_column(Float)
+    rating_overall: Mapped[Optional[float]] = mapped_column(Float)
+    last_review_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True))
+    
     vibe_analysis: Mapped[Any] = mapped_column(JSONB, server_default=text("'{}'::jsonb"))
     social_links: Mapped[Any] = mapped_column(JSONB, server_default=text("'{}'::jsonb"))
     specialization_tags: Mapped[Any] = mapped_column(JSONB, server_default=text("'{}'::jsonb"))
@@ -50,6 +59,7 @@ class ServiceProfile(Base):
     # Kapcsolatok
     organization: Mapped["Organization"] = relationship("Organization", back_populates="service_profile")
     expertises: Mapped[List["ServiceExpertise"]] = relationship("ServiceExpertise", back_populates="service")
+    reviews: Mapped[List["ServiceReview"]] = relationship("ServiceReview", back_populates="service")
     
     created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
     updated_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), onupdate=func.now())
@@ -60,7 +70,7 @@ class ExpertiseTag(Base):
     Ez a tábla vezérli a robotok keresését és a Gamification pontozást is.
     """
     __tablename__ = "expertise_tags"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "marketplace"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     
@@ -114,11 +124,11 @@ class ServiceExpertise(Base):
     Itt tároljuk, hogy az adott szerviznél mennyire validált egy szakma.
     """
     __tablename__ = "service_expertises"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "marketplace"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    service_id: Mapped[int] = mapped_column(Integer, ForeignKey("data.service_profiles.id", ondelete="CASCADE"))
-    expertise_id: Mapped[int] = mapped_column(Integer, ForeignKey("data.expertise_tags.id", ondelete="CASCADE"))
+    service_id: Mapped[int] = mapped_column(Integer, ForeignKey("marketplace.service_profiles.id", ondelete="CASCADE"))
+    expertise_id: Mapped[int] = mapped_column(Integer, ForeignKey("marketplace.expertise_tags.id", ondelete="CASCADE"))
     
     # Mennyire biztos ez a tudás? (0: robot találta, 1: júzer mondta, 2: igazolt szakma)
     confidence_level: Mapped[int] = mapped_column(Integer, default=0, server_default=text("0"))
@@ -134,7 +144,7 @@ class ServiceStaging(Base):
     __tablename__ = "service_staging"
     __table_args__ = (
         Index('idx_staging_fingerprint', 'fingerprint', unique=True),
-        {"schema": "data"}
+        {"schema": "marketplace"}
     )
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
@@ -150,7 +160,7 @@ class ServiceStaging(Base):
 class DiscoveryParameter(Base):
     """ Robot vezérlési paraméterek adminból. """
     __tablename__ = "discovery_parameters"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "marketplace"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     city: Mapped[str] = mapped_column(String(100))

backend/app/models/social.py

@@ -1,12 +1,13 @@
 # /opt/docker/dev/service_finder/backend/app/models/social.py
 import enum
+import uuid
 from datetime import datetime
 from typing import Optional, List
 from sqlalchemy import String, Integer, ForeignKey, DateTime, Boolean, Text, UniqueConstraint, text
 from sqlalchemy.orm import Mapped, mapped_column, relationship
-from sqlalchemy.dialects.postgresql import ENUM as PG_ENUM
+from sqlalchemy.dialects.postgresql import ENUM as PG_ENUM, UUID as PG_UUID
 from sqlalchemy.sql import func
-from app.db.base_class import Base
+from app.database import Base
 
 class ModerationStatus(str, enum.Enum):
     pending = "pending"
@@ -21,6 +22,7 @@ class SourceType(str, enum.Enum):
 class ServiceProvider(Base):
     """ Közösség által beküldött szolgáltatók (v1.3.1). """
     __tablename__ = "service_providers"
+    __table_args__ = {"schema": "marketplace"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     name: Mapped[str] = mapped_column(String, nullable=False)
@@ -28,11 +30,11 @@ class ServiceProvider(Base):
     category: Mapped[Optional[str]] = mapped_column(String)
     
     status: Mapped[ModerationStatus] = mapped_column(
-        PG_ENUM(ModerationStatus, name="moderation_status", inherit_schema=True), 
+        PG_ENUM(ModerationStatus, name="moderation_status", inherit_schema=True),
         default=ModerationStatus.pending
     )
     source: Mapped[SourceType] = mapped_column(
-        PG_ENUM(SourceType, name="source_type", inherit_schema=True), 
+        PG_ENUM(SourceType, name="source_type", inherit_schema=True),
         default=SourceType.manual
     )
     
@@ -46,16 +48,18 @@ class Vote(Base):
     __tablename__ = "votes"
     __table_args__ = (
         UniqueConstraint('user_id', 'provider_id', name='uq_user_provider_vote'),
+        {"schema": "marketplace"}
     )
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     user_id: Mapped[int] = mapped_column(Integer, ForeignKey("identity.users.id"), nullable=False)
-    provider_id: Mapped[int] = mapped_column(Integer, ForeignKey("data.service_providers.id"), nullable=False)
+    provider_id: Mapped[int] = mapped_column(Integer, ForeignKey("marketplace.service_providers.id"), nullable=False)
     vote_value: Mapped[int] = mapped_column(Integer, nullable=False) # +1 vagy -1
 
 class Competition(Base):
     """ Gamifikált versenyek (pl. Januári Feltöltő Verseny). """
     __tablename__ = "competitions"
+    __table_args__ = {"schema": "system"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     name: Mapped[str] = mapped_column(String, nullable=False)
@@ -69,10 +73,44 @@ class UserScore(Base):
     __tablename__ = "user_scores"
     __table_args__ = (
         UniqueConstraint('user_id', 'competition_id', name='uq_user_competition_score'),
+        {"schema": "system"}
     )
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     user_id: Mapped[int] = mapped_column(Integer, ForeignKey("identity.users.id"))
-    competition_id: Mapped[int] = mapped_column(Integer, ForeignKey("data.competitions.id"))
+    competition_id: Mapped[int] = mapped_column(Integer, ForeignKey("system.competitions.id"))
     points: Mapped[int] = mapped_column(Integer, default=0)
-    last_updated: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+    last_updated: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), onupdate=func.now())
+
+
+class ServiceReview(Base):
+    """
+    Verifikált szerviz értékelések (Social 3).
+    Csak igazolt pénzügyi tranzakció után lehet értékelni.
+    """
+    __tablename__ = "service_reviews"
+    __table_args__ = (
+        UniqueConstraint('transaction_id', name='uq_service_review_transaction'),
+        {"schema": "marketplace"}
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    service_id: Mapped[int] = mapped_column(Integer, ForeignKey("marketplace.service_profiles.id", ondelete="CASCADE"), nullable=False)
+    user_id: Mapped[int] = mapped_column(Integer, ForeignKey("identity.users.id", ondelete="SET NULL"), nullable=False)
+    transaction_id: Mapped[uuid.UUID] = mapped_column(PG_UUID(as_uuid=True), nullable=False, index=True)
+    
+    # Rating dimensions (1-10)
+    price_rating: Mapped[int] = mapped_column(Integer, nullable=False)  # 1-10
+    quality_rating: Mapped[int] = mapped_column(Integer, nullable=False)  # 1-10
+    time_rating: Mapped[int] = mapped_column(Integer, nullable=False)  # 1-10
+    communication_rating: Mapped[int] = mapped_column(Integer, nullable=False)  # 1-10
+    
+    comment: Mapped[Optional[str]] = mapped_column(Text)
+    is_verified: Mapped[bool] = mapped_column(Boolean, default=True, server_default=text("true"))
+    
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    updated_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), onupdate=func.now())
+    
+    # Relationships
+    service: Mapped["ServiceProfile"] = relationship("ServiceProfile", back_populates="reviews")
+    user: Mapped["User"] = relationship("User", back_populates="service_reviews")

backend/app/models/staged_data.py

@@ -10,7 +10,7 @@ from app.db.base_class import Base
 class StagedVehicleData(Base):
     """ Robot 2.1 (Researcher) nyers adatgyűjtője. """
     __tablename__ = "staged_vehicle_data"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "system"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     source_url: Mapped[Optional[str]] = mapped_column(String)
@@ -24,7 +24,7 @@ class StagedVehicleData(Base):
 class ServiceStaging(Base):
     """ Robot 1.3 (Scout) által talált nyers szerviz adatok. """
     __tablename__ = "service_staging"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "system"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     name: Mapped[str] = mapped_column(String(255), index=True)
@@ -47,10 +47,10 @@ class ServiceStaging(Base):
 class DiscoveryParameter(Base):
     """ Felderítési paraméterek (Városok, ahol a Scout keres). """
     __tablename__ = "discovery_parameters"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "marketplace"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     city: Mapped[str] = mapped_column(String(100), unique=True, index=True)
-    country_code: Mapped[str] = mapped_column(String(5), server_default=text("'HU'"))
+    keyword: Mapped[Optional[str]] = mapped_column(String(100), nullable=True)
     is_active: Mapped[bool] = mapped_column(Boolean, default=True)
     last_run_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True))

backend/app/models/system.py

@@ -1,19 +1,26 @@
 # /opt/docker/dev/service_finder/backend/app/models/system.py
 import uuid
 from datetime import datetime
+from enum import Enum
 from typing import Optional
-from sqlalchemy import String, Integer, Boolean, DateTime, text, UniqueConstraint, ForeignKey, Text
+from sqlalchemy import String, Integer, Boolean, DateTime, text, UniqueConstraint, ForeignKey, Text, Enum as SQLEnum
 from sqlalchemy.orm import Mapped, mapped_column
 from sqlalchemy.dialects.postgresql import JSONB, UUID
 from sqlalchemy.sql import func
-from app.db.base_class import Base
+from app.database import Base
+
+class ParameterScope(str, Enum):
+    GLOBAL = "global"
+    COUNTRY = "country"
+    REGION = "region"
+    USER = "user"
 
 class SystemParameter(Base):
     """ Dinamikus konfigurációs motor (Global -> Org -> User). """
     __tablename__ = "system_parameters"
     __table_args__ = (
         UniqueConstraint('key', 'scope_level', 'scope_id', name='uix_param_scope'),
-        {"extend_existing": True}
+        {"schema": "system", "extend_existing": True}
     )
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
@@ -21,8 +28,8 @@ class SystemParameter(Base):
     category: Mapped[str] = mapped_column(String, server_default="general", index=True)
     value: Mapped[dict] = mapped_column(JSONB, nullable=False)
     
-    scope_level: Mapped[str] = mapped_column(String(30), server_default=text("'global'"), index=True)
-    scope_id: Mapped[Optional[str]] = mapped_column(String(50)) 
+    scope_level: Mapped[ParameterScope] = mapped_column(SQLEnum(ParameterScope, name="parameter_scope"), server_default=ParameterScope.GLOBAL.value, index=True)
+    scope_id: Mapped[Optional[str]] = mapped_column(String(50))
     
     is_active: Mapped[bool] = mapped_column(Boolean, default=True)
     description: Mapped[Optional[str]] = mapped_column(String)
@@ -35,7 +42,7 @@ class InternalNotification(Base):
     Ezek az üzenetek várják a felhasználót belépéskor.
     """
     __tablename__ = "internal_notifications"
-    __table_args__ = ({"schema": "data", "extend_existing": True})
+    __table_args__ = ({"schema": "system", "extend_existing": True})
 
     id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
     user_id: Mapped[int] = mapped_column(ForeignKey("identity.users.id", ondelete="CASCADE"), nullable=False, index=True)

backend/app/models/translation.py

@@ -10,7 +10,7 @@ class Translation(Base):
     Többnyelvűséget támogató tábla a felületi elemekhez és dinamikus tartalmakhoz.
     """
     __tablename__ = "translations"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "system"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     

backend/app/models/vehicle.py

@@ -0,0 +1,192 @@
+# /opt/docker/dev/service_finder/backend/app/models/vehicle.py
+"""
+TCO (Total Cost of Ownership) alapmodelljei a 'vehicle' sémában.
+- CostCategory: Standardizált költségkategóriák hierarchiája
+- VehicleCost: Járműhöz kapcsolódó tényleges költségnapló
+"""
+
+from __future__ import annotations
+from datetime import datetime
+from typing import Optional
+import uuid
+from sqlalchemy import Column, String, Integer, Boolean, DateTime, ForeignKey, Text, Numeric, UniqueConstraint, Float, CheckConstraint
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.sql import func
+from app.database import Base
+
+
+class CostCategory(Base):
+    """
+    Standardizált költségkategóriák hierarchikus fája.
+    Rendszerkategóriák (is_system=True) nem törölhetők, csak felhasználói kategóriák.
+    """
+    __tablename__ = "cost_categories"
+    __table_args__ = {"schema": "vehicle"}
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    parent_id: Mapped[Optional[int]] = mapped_column(
+        Integer, 
+        ForeignKey("vehicle.cost_categories.id", ondelete="SET NULL"),
+        nullable=True,
+        index=True
+    )
+    code: Mapped[str] = mapped_column(String(50), unique=True, index=True, nullable=False)
+    name: Mapped[str] = mapped_column(String(100), nullable=False)
+    description: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
+    is_system: Mapped[bool] = mapped_column(Boolean, default=False, server_default="false")
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), onupdate=func.now(), server_default=func.now())
+
+    # Hierarchikus kapcsolatok
+    parent: Mapped[Optional["CostCategory"]] = relationship(
+        "CostCategory", 
+        remote_side=[id],
+        back_populates="children",
+        foreign_keys=[parent_id]
+    )
+    children: Mapped[list["CostCategory"]] = relationship(
+        "CostCategory", 
+        back_populates="parent",
+        foreign_keys=[parent_id]
+    )
+    
+    # Kapcsolódó költségek
+    costs: Mapped[list["VehicleCost"]] = relationship("VehicleCost", back_populates="category")
+
+    def __repr__(self) -> str:
+        return f"CostCategory(id={self.id}, code='{self.code}', name='{self.name}')"
+
+
+class VehicleCost(Base):
+    """
+    Járműhöz kapcsolódó tényleges költségnapló.
+    Minden költséghez kötelező az odometer állás (km) és a dátum.
+    Az organization_id az Univerzális Flotta hivatkozás (fleet.organizations).
+    """
+    __tablename__ = "costs"
+    __table_args__ = (
+        UniqueConstraint("vehicle_id", "category_id", "date", "odometer", name="uq_cost_unique_entry"),
+        {"schema": "vehicle"}
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    vehicle_id: Mapped[int] = mapped_column(
+        Integer, 
+        ForeignKey("vehicle.vehicle_model_definitions.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True
+    )
+    organization_id: Mapped[Optional[int]] = mapped_column(
+        Integer,
+        ForeignKey("fleet.organizations.id", ondelete="SET NULL"),
+        nullable=True,
+        index=True
+    )
+    category_id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey("vehicle.cost_categories.id", ondelete="RESTRICT"),
+        nullable=False,
+        index=True
+    )
+    amount: Mapped[float] = mapped_column(Numeric(12, 2), nullable=False)  # Összeg
+    currency: Mapped[str] = mapped_column(String(3), default="HUF", server_default="'HUF'")  # ISO valutakód
+    odometer: Mapped[int] = mapped_column(Integer, nullable=False)  # Kilométeróra állás (km)
+    date: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, index=True)
+    notes: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), onupdate=func.now(), server_default=func.now())
+
+    # Kapcsolatok
+    vehicle: Mapped["VehicleModelDefinition"] = relationship("VehicleModelDefinition", back_populates="costs")
+    organization: Mapped[Optional["Organization"]] = relationship("Organization", back_populates="vehicle_costs")
+    category: Mapped["CostCategory"] = relationship("CostCategory", back_populates="costs")
+
+    def __repr__(self) -> str:
+        return f"VehicleCost(id={self.id}, vehicle_id={self.vehicle_id}, amount={self.amount} {self.currency})"
+
+
+class VehicleOdometerState(Base):
+    """
+    Jármű kilométeróra állapotának és becslésének tárolása.
+    Adminisztrátor által paraméterezhető algoritmusokkal működik.
+    """
+    __tablename__ = "vehicle_odometer_states"
+    __table_args__ = {"schema": "vehicle"}
+
+    vehicle_id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey("vehicle.vehicle_model_definitions.id", ondelete="CASCADE"),
+        primary_key=True,
+        nullable=False
+    )
+    last_recorded_odometer: Mapped[int] = mapped_column(Integer, nullable=False)
+    last_recorded_date: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+    daily_avg_distance: Mapped[float] = mapped_column(Numeric(10, 2), nullable=False)
+    estimated_current_odometer: Mapped[float] = mapped_column(Numeric(12, 2), nullable=False)
+    confidence_score: Mapped[float] = mapped_column(Float, nullable=False, default=0.0)
+    manual_override_avg: Mapped[Optional[float]] = mapped_column(Numeric(10, 2), nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), onupdate=func.now(), server_default=func.now())
+
+    # Kapcsolat a jármű definícióval
+    vehicle: Mapped["VehicleModelDefinition"] = relationship("VehicleModelDefinition", back_populates="odometer_state")
+
+    def __repr__(self) -> str:
+        return f"VehicleOdometerState(vehicle_id={self.vehicle_id}, estimated={self.estimated_current_odometer}, confidence={self.confidence_score})"
+
+
+class VehicleUserRating(Base):
+    """
+    Jármű értékelési rendszer - User -> Vehicle kapcsolat.
+    Egy felhasználó csak egyszer értékelhet egy adott járművet.
+    Értékelés 4 dimenzióban 1-10 skálán.
+    """
+    __tablename__ = "vehicle_user_ratings"
+    __table_args__ = (
+        UniqueConstraint("vehicle_id", "user_id", name="uq_vehicle_user_rating_unique"),
+        CheckConstraint("driving_experience BETWEEN 1 AND 10", name="ck_driving_experience_range"),
+        CheckConstraint("reliability BETWEEN 1 AND 10", name="ck_reliability_range"),
+        CheckConstraint("comfort BETWEEN 1 AND 10", name="ck_comfort_range"),
+        CheckConstraint("consumption_satisfaction BETWEEN 1 AND 10", name="ck_consumption_satisfaction_range"),
+        {"schema": "vehicle"}
+    )
+
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True),
+        primary_key=True,
+        default=uuid.uuid4,
+        server_default=func.gen_random_uuid()
+    )
+    vehicle_id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey("vehicle.vehicle_model_definitions.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True
+    )
+    user_id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey("identity.users.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True
+    )
+    driving_experience: Mapped[int] = mapped_column(Integer, nullable=False)
+    reliability: Mapped[int] = mapped_column(Integer, nullable=False)
+    comfort: Mapped[int] = mapped_column(Integer, nullable=False)
+    consumption_satisfaction: Mapped[int] = mapped_column(Integer, nullable=False)
+    comment: Mapped[Optional[str]] = mapped_column(Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), onupdate=func.now(), server_default=func.now())
+
+    # Kapcsolatok
+    vehicle: Mapped["VehicleModelDefinition"] = relationship("VehicleModelDefinition", back_populates="ratings")
+    user: Mapped["User"] = relationship("User", back_populates="vehicle_ratings")
+
+    def __repr__(self) -> str:
+        return f"VehicleUserRating(id={self.id}, vehicle_id={self.vehicle_id}, user_id={self.user_id})"
+
+    @property
+    def average_score(self) -> float:
+        """Számított átlagpontszám a 4 dimenzióból."""
+        scores = [self.driving_experience, self.reliability, self.comfort, self.consumption_satisfaction]
+        return sum(scores) / 4.0

backend/app/models/vehicle_definitions.py

@@ -13,7 +13,7 @@ from app.database import Base
 class VehicleType(Base):
     """ Jármű kategóriák (pl. Személyautó, Motorkerékpár, Teherautó, Hajó) """
     __tablename__ = "vehicle_types"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "vehicle"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
     code: Mapped[str] = mapped_column(String(30), unique=True, index=True) 
@@ -29,10 +29,10 @@ class VehicleType(Base):
 class FeatureDefinition(Base):
     """ Felszereltségi elemek definíciója (pl. ABS, Klíma, LED fényszóró) """
     __tablename__ = "feature_definitions"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "vehicle"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    vehicle_type_id: Mapped[int] = mapped_column(Integer, ForeignKey("data.vehicle_types.id"))
+    vehicle_type_id: Mapped[int] = mapped_column(Integer, ForeignKey("vehicle.vehicle_types.id"))
     code: Mapped[str] = mapped_column(String(50), index=True) 
     name: Mapped[str] = mapped_column(String(100))
     category: Mapped[str] = mapped_column(String(50), index=True) 
@@ -48,7 +48,7 @@ class VehicleModelDefinition(Base):
     Az ökoszisztéma technikai igazságforrása.
     """
     __tablename__ = "vehicle_model_definitions"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "vehicle"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
     make: Mapped[str] = mapped_column(String(100), index=True)
@@ -89,7 +89,7 @@ class VehicleModelDefinition(Base):
 
 
     # --- SPECIFIKÁCIÓK ---
-    vehicle_type_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("data.vehicle_types.id"))
+    vehicle_type_id: Mapped[Optional[int]] = mapped_column(Integer, ForeignKey("vehicle.vehicle_types.id"))
     vehicle_class: Mapped[Optional[str]] = mapped_column(String(50), index=True)
     body_type: Mapped[Optional[str]] = mapped_column(String(100))
     fuel_type: Mapped[Optional[str]] = mapped_column(String(50), index=True)
@@ -130,7 +130,7 @@ class VehicleModelDefinition(Base):
         UniqueConstraint('make', 'normalized_name', 'variant_code', 'version_code', 'fuel_type', 'market', 'year_from', name='uix_vmd_precision_v2'),
         Index('idx_vmd_lookup_fast', 'make', 'normalized_name'),
         Index('idx_vmd_engine_bridge', 'make', 'engine_code'),
-        {"schema": "data"}
+        {"schema": "vehicle"}
     )
 
     # KAPCSOLATOK
@@ -138,18 +138,23 @@ class VehicleModelDefinition(Base):
     feature_maps: Mapped[List["ModelFeatureMap"]] = relationship("ModelFeatureMap", back_populates="model_definition")
     
     # Hivatkozás az asset.py-ban lévő osztályra
-    # Megjegyzés: Ha az AssetCatalog nincs itt importálva, húzzal adjuk meg a nevet
+    # Megjegyzés: Ha az AssetCatalog nincs itt importálva, húzzal adjuk meg a neve
     variants: Mapped[List["AssetCatalog"]] = relationship("AssetCatalog", back_populates="master_definition")
+    
+    # TCO költségnapló kapcsolata
+    costs: Mapped[List["VehicleCost"]] = relationship("VehicleCost", back_populates="vehicle")
+    # Kilométeróra állapot kapcsolata
+    odometer_state: Mapped["VehicleOdometerState"] = relationship("VehicleOdometerState", back_populates="vehicle")
 
 
 class ModelFeatureMap(Base):
     """ Kapcsolótábla a modellek és az alapfelszereltség között """
     __tablename__ = "model_feature_maps"
-    __table_args__ = {"schema": "data"}
+    __table_args__ = {"schema": "vehicle"}
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    model_definition_id: Mapped[int] = mapped_column(Integer, ForeignKey("data.vehicle_model_definitions.id"))
-    feature_id: Mapped[int] = mapped_column(Integer, ForeignKey("data.feature_definitions.id"))
+    model_definition_id: Mapped[int] = mapped_column(Integer, ForeignKey("vehicle.vehicle_model_definitions.id"))
+    feature_id: Mapped[int] = mapped_column(Integer, ForeignKey("vehicle.feature_definitions.id"))
     is_standard: Mapped[bool] = mapped_column(Boolean, default=True)
 
     model_definition: Mapped["VehicleModelDefinition"] = relationship("VehicleModelDefinition", back_populates="feature_maps")

backend/app/schemas/admin.py

@@ -38,12 +38,12 @@ async def get_system_health(
     stats = {}
     
     # Felhasználói eloszlás (Nyers SQL a sebességért)
-    user_res = await db.execute(text("SELECT subscription_plan, count(*) FROM data.users GROUP BY subscription_plan"))
+    user_res = await db.execute(text("SELECT subscription_plan, count(*) FROM identity.users GROUP BY subscription_plan"))
     stats["user_distribution"] = {row[0]: row[1] for row in user_res}
     
     # Eszköz és Szervezet számlálók
-    stats["total_assets"] = (await db.execute(text("SELECT count(*) FROM data.assets"))).scalar()
-    stats["total_organizations"] = (await db.execute(text("SELECT count(*) FROM data.organizations"))).scalar()
+    stats["total_assets"] = (await db.execute(text("SELECT count(*) FROM vehicle.assets"))).scalar()
+    stats["total_organizations"] = (await db.execute(text("SELECT count(*) FROM fleet.organizations"))).scalar()
 
     # Biztonsági riasztások (Kritikus logok az elmúlt 24 órában)
     day_ago = datetime.now() - timedelta(days=1)
@@ -99,7 +99,7 @@ async def set_parameter(
 ):
     """ Paraméter beállítása vagy frissítése hierarchikus scope-al. """
     query = text("""
-        INSERT INTO data.system_parameters (key, value, scope_level, scope_id, category, last_modified_by)
+        INSERT INTO system.system_parameters (key, value, scope_level, scope_id, category, last_modified_by)
         VALUES (:key, :val, :sl, :sid, :cat, :user)
         ON CONFLICT (key, scope_level, scope_id) 
         DO UPDATE SET 

backend/app/schemas/analytics.py

@@ -0,0 +1,46 @@
+"""
+Analytics Pydantic schemas for TCO (Total Cost of Ownership) API responses.
+"""
+
+from typing import List, Optional, Dict, Any
+from pydantic import BaseModel, Field
+
+
+class TCOResponse(BaseModel):
+    """Response schema for a single TCO category breakdown."""
+    category_id: int = Field(..., description="Cost category ID")
+    category_code: str = Field(..., description="Category code (e.g., 'FUEL', 'MAINTENANCE')")
+    category_name: str = Field(..., description="Human-readable category name")
+    amount: float = Field(..., description="Total amount in original currency")
+    currency: str = Field(..., description="Original currency code (e.g., 'EUR', 'HUF')")
+    amount_huf: float = Field(..., description="Amount converted to HUF")
+    percentage: float = Field(..., description="Percentage of total cost (0-100)")
+
+    class Config:
+        from_attributes = True
+
+
+class TCOSummaryStats(BaseModel):
+    """Statistics part of the TCO summary."""
+    total_cost: float = Field(..., description="Total cost in HUF")
+    cost_per_km: Optional[float] = Field(None, description="Cost per kilometer (HUF/km)")
+    total_transactions: int = Field(..., description="Number of cost transactions")
+    date_range: Optional[Dict[str, str]] = Field(None, description="Start and end dates if filtered")
+
+
+class TCOSummaryResponse(BaseModel):
+    """Complete TCO summary for a vehicle."""
+    vehicle_id: int = Field(..., description="Vehicle ID")
+    user_tco: List[TCOResponse] = Field(..., description="TCO breakdown for the current user/organization")
+    lifetime_tco: List[TCOResponse] = Field(..., description="Lifetime TCO across all owners (anonymized)")
+    benchmark_tco: List[TCOResponse] = Field(..., description="Benchmark TCO for similar vehicles")
+    stats: TCOSummaryStats = Field(..., description="Aggregated statistics")
+
+    class Config:
+        from_attributes = True
+
+
+class TCOErrorResponse(BaseModel):
+    """Error response for TCO endpoints."""
+    detail: str = Field(..., description="Error description")
+    vehicle_id: Optional[int] = Field(None, description="Related vehicle ID if applicable")

backend/app/schemas/finance.py

@@ -0,0 +1,43 @@
+# /opt/docker/dev/service_finder/backend/app/schemas/finance.py
+"""
+Finance-related Pydantic schemas for API requests and responses.
+"""
+
+from pydantic import BaseModel, ConfigDict
+from datetime import datetime
+from typing import Optional, Any, Dict, List
+import enum
+
+
+class IssuerType(str, enum.Enum):
+    """Kibocsátó típusok (jogi forma)."""
+    KFT = "KFT"
+    EV = "EV"
+    BT = "BT"
+    ZRT = "ZRT"
+    OTHER = "OTHER"
+
+
+class IssuerResponse(BaseModel):
+    """Response schema for Issuer entities."""
+    id: int
+    name: str
+    tax_id: Optional[str] = None
+    type: IssuerType
+    revenue_limit: float
+    current_revenue: float
+    is_active: bool
+    api_config: Dict[str, Any]
+    created_at: datetime
+    updated_at: datetime
+
+    model_config = ConfigDict(from_attributes=True)
+
+
+class IssuerUpdate(BaseModel):
+    """Update schema for Issuer entities (PATCH)."""
+    is_active: Optional[bool] = None
+    revenue_limit: Optional[float] = None
+    api_config: Optional[Dict[str, Any]] = None
+
+    model_config = ConfigDict(from_attributes=True)

backend/app/schemas/social.py

@@ -1,4 +1,4 @@
-# /opt/docker/dev/service_finder/backend/app/schemas/social.py
+import uuid  # HOZZÁADVA
 from pydantic import BaseModel, ConfigDict
 from typing import Optional, List
 from datetime import datetime
@@ -27,6 +27,28 @@ class ServiceProviderResponse(ServiceProviderBase):
     
     model_config = ConfigDict(from_attributes=True)
 
+# --- Értékelések (Reviews) - HOZZÁADVA ---
+
+class ServiceReviewBase(BaseModel):
+    price_rating: int
+    quality_rating: int
+    time_rating: int
+    communication_rating: int
+    comment: Optional[str] = None
+
+class ServiceReviewCreate(ServiceReviewBase):
+    pass
+
+class ServiceReviewResponse(ServiceReviewBase):
+    id: int
+    user_id: int
+    service_id: int
+    transaction_id: uuid.UUID
+    is_verified: bool
+    created_at: datetime
+    
+    model_config = ConfigDict(from_attributes=True)
+
 # --- Gamifikáció és Szavazás (Voting & Gamification) ---
 
 class VoteCreate(BaseModel):
@@ -43,15 +65,15 @@ class BadgeSchema(BaseModel):
     id: int
     name: str
     description: str
-    icon_url: Optional[str] = None # JAVÍTVA: icon_url a modell szerint
+    icon_url: Optional[str] = None
     
-    model_config = ConfigDict(from_attributes=True) # Pydantic V2 kompatibilis
+    model_config = ConfigDict(from_attributes=True)
 
 class UserStatSchema(BaseModel):
     user_id: int
-    total_xp: int # JAVÍTVA: total_xp a modell szerint
+    total_xp: int
     current_level: int
-    penalty_points: int # JAVÍTVA: új mező
+    penalty_points: int
     rank_title: Optional[str] = None
     badges: List[BadgeSchema] = []
     

backend/app/schemas/vehicle.py

@@ -0,0 +1,56 @@
+"""
+Jármű értékelési sémák a Social 1 modulhoz.
+"""
+from pydantic import BaseModel, Field, validator
+from typing import Optional
+from uuid import UUID
+from datetime import datetime
+
+
+class VehicleRatingCreate(BaseModel):
+    """Értékelés beküldéséhez használt séma."""
+    driving_experience: int = Field(..., ge=1, le=10, description="Vezetési élmény 1-10 skálán")
+    reliability: int = Field(..., ge=1, le=10, description="Megbízhatóság 1-10 skálán")
+    comfort: int = Field(..., ge=1, le=10, description="Kényelem 1-10 skálán")
+    consumption_satisfaction: int = Field(..., ge=1, le=10, description="Fogyasztás elégedettség 1-10 skálán")
+    comment: Optional[str] = Field(None, max_length=1000, description="Opcionális megjegyzés")
+
+    @validator('driving_experience', 'reliability', 'comfort', 'consumption_satisfaction')
+    def validate_rating_range(cls, v):
+        if not 1 <= v <= 10:
+            raise ValueError('Értékelésnek 1 és 10 között kell lennie')
+        return v
+
+
+class VehicleRatingResponse(BaseModel):
+    """Értékelés válasza, tartalmazza a számított átlagpontszámot."""
+    id: UUID
+    vehicle_id: int
+    user_id: int
+    driving_experience: int
+    reliability: int
+    comfort: int
+    consumption_satisfaction: int
+    comment: Optional[str]
+    average_score: float = Field(..., description="Számított átlagpontszám (4 dimenzió átlaga)")
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True
+
+    @validator('average_score', pre=True, always=True)
+    def calculate_average(cls, v, values):
+        """Számolja ki az átlagpontszámot, ha nincs megadva."""
+        if v is not None:
+            return v
+        # Ha nincs megadva, számoljuk ki a 4 dimenzióból
+        scores = [
+            values.get('driving_experience'),
+            values.get('reliability'),
+            values.get('comfort'),
+            values.get('consumption_satisfaction')
+        ]
+        if any(score is None for score in scores):
+            raise ValueError('Nem lehet kiszámolni az átlagot hiányzó értékelések miatt')
+        return sum(scores) / 4.0

backend/app/schemas/vehicle.py.old

@@ -1,30 +0,0 @@
-from pydantic import BaseModel, Field, validator
-from typing import Optional, List, Any
-from uuid import UUID
-from datetime import datetime
-
-class EngineSpecBase(BaseModel):
-    engine_code: str
-    fuel_type: str
-    power_kw: int
-    default_service_interval_km: int = 15000
-
-class VehicleBase(BaseModel):
-    brand_id: int
-    model_name: str
-    identification_number: str
-    license_plate: Optional[str] = None
-    tracking_mode: str = "km"
-
-class VehicleCreate(VehicleBase):
-    current_company_id: int
-    engine_spec_id: int
-
-class VehicleRead(VehicleBase):
-    id: UUID
-    current_rating_pct: int
-    total_real_usage: float
-    created_at: datetime
-
-    class Config:
-        from_attributes = True

backend/app/scripts/discovery_bot.py.veryold

@@ -1,38 +0,0 @@
-import asyncio
-import httpx
-from sqlalchemy import text
-from app.db.session import engine
-from datetime import datetime
-
-async def log_discovery(conn, category, brand, model, action):
-    await conn.execute(text("""
-        INSERT INTO data.bot_discovery_logs (category, brand_name, model_name, action_taken)
-        VALUES (:c, :b, :m, :a)
-    """), {"c": category, "b": brand, "m": model, "a": action})
-
-async def run_discovery():
-    async with engine.begin() as conn:
-        print(f"🚀 Jármű felfedezés indul: {datetime.now()}")
-        
-        # Jelenleg a CAR kategóriára fókuszálunk egy külső API segítségével (pl. NHTSA - Ingyenes)
-        # Itt egy példa, hogyan bővül dinamikusan a rendszer
-        async with httpx.AsyncClient() as client:
-            # Autók lekérése
-            response = await client.get("https://vpic.nhtsa.dot.gov/api/vehicles/getallmakes?format=json")
-            if response.status_code == 200:
-                makes = response.json().get('Results', [])[:100] # Tesztként az első 100
-                
-                for make in makes:
-                    brand_name = make['Make_Name'].strip()
-                    # Megnézzük, megvan-e már
-                    res = await conn.execute(text("SELECT id FROM data.vehicle_brands WHERE name = :n"), {"n": brand_name})
-                    if not res.scalar():
-                        await conn.execute(text("INSERT INTO data.vehicle_brands (category_id, name) VALUES (1, :n)"), {"n": brand_name})
-                        await log_discovery(conn, "CAR", brand_name, "ALL", "NEW_BRAND")
-                        print(f"✨ Új márka találva: {brand_name}")
-        
-        await conn.commit()
-        print("✅ Bot futása befejeződött.")
-
-if __name__ == "__main__":
-    asyncio.run(run_discovery())

backend/app/scripts/pre_start.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+set -e
+
+echo "🚀 Service Finder Pre‑Start Schema Synchronization"
+echo "=================================================="
+
+# Ensure we are in the correct directory (should be /app inside container)
+cd /app
+
+# Run the unified database synchronizer with --apply flag
+echo "📦 Running unified_db_sync.py --apply..."
+python -m app.scripts.unified_db_sync --apply
+
+# Verify that the sync succeeded
+if [ $? -eq 0 ]; then
+    echo "✅ Schema synchronization completed successfully."
+else
+    echo "❌ Schema synchronization failed. Exiting."
+    exit 1
+fi
+
+# Start the FastAPI application
+echo "🌐 Starting FastAPI server..."
+exec uvicorn app.main:app --host 0.0.0.0 --port 8000

backend/app/scripts/seed_system_params.py

@@ -298,6 +298,34 @@ async def seed_params():
                 "description": "Robot 1 - Számla OCR prompt",
                 "scope_level": "global"
             },
+
+            # --- 13. SOCIAL & VERIFIED REVIEWS (Epic 4.1 - #66) ---
+            {
+                "key": "REVIEW_WINDOW_DAYS",
+                "value": 30,
+                "category": "social",
+                "description": "Értékelési időablak napokban a tranzakció után",
+                "scope_level": "global"
+            },
+            {
+                "key": "TRUST_SCORE_INFLUENCE_FACTOR",
+                "value": 1.0,
+                "category": "social",
+                "description": "Trust‑score súlyozási tényező a szerviz értékeléseknél",
+                "scope_level": "global"
+            },
+            {
+                "key": "REVIEW_RATING_WEIGHTS",
+                "value": {
+                    "price": 0.25,
+                    "quality": 0.35,
+                    "time": 0.20,
+                    "communication": 0.20
+                },
+                "category": "social",
+                "description": "Értékelési dimenziók súlyai az összpontszám számításához",
+                "scope_level": "global"
+            },
             {
                 "key": "ai_prompt_gold_data",
                 "value": "Készíts technikai adatlapot a(z) {make} {model} típushoz a megadott adatok alapján: {context}. Csak hiteles JSON-t adj!",

backend/app/scripts/sync_engine.py

@@ -0,0 +1,169 @@
+#!/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_audit.py

@@ -0,0 +1,133 @@
+import asyncio
+import os
+import sys
+import importlib.util
+from pathlib import Path
+from sqlalchemy import inspect, text
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy.dialects.postgresql import JSONB, ENUM, NUMERIC
+
+# Elérési utak beállítása
+BASE_DIR = Path(__file__).resolve().parents[2]
+sys.path.append(str(BASE_DIR))
+
+try:
+    from app.database import Base, engine
+    from app.core.config import settings
+except ImportError as e:
+    print(f"❌ Hiba az alapvető importoknál: {e}")
+    sys.exit(1)
+
+def dynamic_import_models(models_dir: Path):
+    """
+    Automatikusan bejárja az app/models mappát és beimportál minden .py fájlt,
+    hogy a Base.metadata.tables feltöltődjön.
+    """
+    print(f"🔍 Modellek dinamikus felderítése itt: {models_dir}...")
+    count = 0
+    for root, _, files in os.walk(models_dir):
+        for file in files:
+            if file.endswith(".py") and file != "__init__.py":
+                full_path = Path(root) / file
+                # Modul név képzése (pl. app.models.identity.user)
+                rel_path = full_path.relative_to(BASE_DIR)
+                module_name = str(rel_path).replace(os.sep, ".").replace(".py", "")
+                
+                try:
+                    spec = importlib.util.spec_from_file_location(module_name, full_path)
+                    module = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(module)
+                    count += 1
+                except Exception as e:
+                    print(f"  ⚠️  Nem sikerült importálni: {module_name} -> {e}")
+    print(f"✅ {count} modell fájl sikeresen betöltve a memóriába.\n")
+
+async def run_unified_audit():
+    # 1. Modellek betöltése
+    models_path = BASE_DIR / "app" / "models"
+    dynamic_import_models(models_path)
+
+    print(f"🔗 Kapcsolódás az adatbázishoz: {settings.POSTGRES_DB}")
+    
+    async with engine.connect() as conn:
+        inspector = await conn.run_sync(inspect)
+        all_db_schemas = await conn.run_sync(lambda c: inspector.get_schema_names())
+        
+        # Kigyűjtjük a modellekben definiált sémákat
+        expected_schemas = sorted({t.schema for t in Base.metadata.sorted_tables if t.schema})
+        
+        mismatches = 0
+        suggestions = []
+
+        for sc in expected_schemas:
+            print(f"\n--- 🛰️ DOMAIN AUDIT: '{sc}' ---")
+            if sc not in all_db_schemas:
+                print(f"❌ KRITIKUS: A(z) '{sc}' séma hiányzik!")
+                mismatches += 1
+                continue
+
+            db_tables = await conn.run_sync(lambda c: inspector.get_table_names(schema=sc))
+            model_tables = [t for t in Base.metadata.sorted_tables if t.schema == sc]
+
+            for table in model_tables:
+                t_name = table.name
+                if t_name not in db_tables:
+                    print(f"❌ HIÁNYZÓ TÁBLA: {sc}.{t_name}")
+                    mismatches += 1
+                    suggestions.append(f"-- Hozd létre a táblát: {sc}.{t_name}")
+                    continue
+
+                # Oszlopok lekérése a DB-ből
+                db_cols = {c['name']: c for c in await conn.run_sync(
+                    lambda c: inspector.get_columns(t_name, schema=sc)
+                )}
+                
+                # Oszlopok lekérése a Modellből
+                for col in table.columns:
+                    if col.name not in db_cols:
+                        print(f"⚠️  HIÁNYZÓ OSZLOP: {sc}.{t_name}.{col.name}")
+                        mismatches += 1
+                        suggestions.append(f"ALTER TABLE {sc}.{t_name} ADD COLUMN {col.name} {col.type};")
+                    else:
+                        # MÉLY TÍPUS ELLENŐRZÉS
+                        db_col = db_cols[col.name]
+                        db_type_str = str(db_col['type']).upper()
+                        
+                        # 1. JSONB Ellenőrzés
+                        if isinstance(col.type, JSONB) and "JSONB" not in db_type_str:
+                            print(f"🔬 TÍPUS ELTÉRÉS [JSONB]: {sc}.{t_name}.{col.name} (DB: {db_type_str})")
+                            mismatches += 1
+
+                        # 2. NUMERIC Precizitás
+                        elif isinstance(col.type, NUMERIC):
+                            m_prec, m_scale = col.type.precision, col.type.scale
+                            d_prec, d_scale = db_col['type'].precision, db_col['type'].scale
+                            if m_prec != d_prec or m_scale != d_scale:
+                                print(f"🔬 TÍPUS ELTÉRÉS [NUMERIC]: {sc}.{t_name}.{col.name} (Kód: {m_prec},{m_scale} vs DB: {d_prec},{d_scale})")
+                                mismatches += 1
+
+                        # 3. ENUM Ellenőrzés
+                        elif isinstance(col.type, ENUM):
+                            enum_name = col.type.name
+                            res = await conn.execute(text(
+                                "SELECT EXISTS (SELECT 1 FROM pg_type WHERE typname = :name)"), 
+                                {"name": enum_name}
+                            )
+                            if not res.scalar():
+                                print(f"🔬 HIÁNYZÓ ENUM TÍPUS: {enum_name} ({sc}.{t_name}.{col.name})")
+                                mismatches += 1
+
+                print(f"✅ {sc}.{t_name:30} | Átvizsgálva.")
+
+        print("\n" + "="*50)
+        if mismatches == 0:
+            print("✨ GRATULÁLOK! A fájlrendszer és az adatbázis szinkronban van. ✨")
+        else:
+            print(f"⚠️  ÖSSZESEN {mismatches} ELTÉRÉS TALÁLHATÓ!")
+            print("\nJAVÍTÁSI JAVASLATOK (Copy-Paste SQL):")
+            for s in suggestions:
+                print(f"  {s}")
+        print("="*50 + "\n")
+
+if __name__ == "__main__":
+    asyncio.run(run_unified_audit())

backend/app/scripts/unified_db_sync.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+import asyncio
+import importlib
+import os
+import sys
+import uuid
+import enum
+from pathlib import Path
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy import inspect, text, UniqueConstraint, Index, Enum as SQLEnum
+from sqlalchemy.schema import CreateTable
+from sqlalchemy.sql import func
+
+# Backend hozzáadása a path-hoz
+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():
+    models_dir = Path(__file__).parent.parent / "models"
+    for py_file in models_dir.glob("*.py"):
+        if py_file.name == "__init__.py": continue
+        module_name = f"app.models.{py_file.stem}"
+        try:
+            importlib.import_module(module_name)
+            print(f"✅ Imported {module_name}")
+        except Exception as e:
+            print(f"⚠️ Could not import {module_name}: {e}")
+    import app.models
+    print(f"📦 Total tables in Base.metadata: {len(Base.metadata.tables)}")
+
+async def compare_and_repair(apply: bool = False):
+    print(f"🔗 Connecting to database... (Apply mode: {apply})")
+    engine = create_async_engine(str(settings.SQLALCHEMY_DATABASE_URI))
+    
+    def get_diff_and_repair(connection):
+        inspector = inspect(connection)
+        
+        # 1. KITERJESZTÉSEK ÉS SÉMÁK
+        schemas = sorted({t.schema for t in Base.metadata.sorted_tables if t.schema})
+        db_schemas = inspector.get_schema_names()
+        
+        if apply:
+            print("🔧 Ensuring extensions and schemas...")
+            connection.execute(text('CREATE EXTENSION IF NOT EXISTS "uuid-ossp"'))
+            try: connection.execute(text('CREATE EXTENSION IF NOT EXISTS "postgis"'))
+            except Exception: pass
+            
+            for schema in schemas:
+                if schema not in db_schemas:
+                    connection.execute(text(f'CREATE SCHEMA IF NOT EXISTS "{schema}"'))
+
+            # Search path beállítása a típusok felismeréséhez
+            search_path = ", ".join([f'"{s}"' for s in schemas]) + ", public"
+            connection.execute(text(f"SET search_path TO {search_path}"))
+
+        # 2. OKOS ENUM LÉTREHOZÁS (Case-Insensitive támogatással)
+        print("🔧 Checking custom Enum types...")
+        for table in Base.metadata.sorted_tables:
+            for col in table.columns:
+                if isinstance(col.type, SQLEnum):
+                    enum_name = col.type.name
+                    schema = table.schema or 'public'
+                    check_enum = connection.execute(text(
+                        "SELECT 1 FROM pg_type t JOIN pg_namespace n ON n.oid = t.typnamespace "
+                        "WHERE t.typname = :name AND n.nspname = :schema"
+                    ), {"name": enum_name, "schema": schema}).fetchone()
+                    
+                    if not check_enum and apply:
+                        # TRÜKK: Hozzáadjuk a kis- és nagybetűs változatokat is, hogy ne bukjon el a DEFAULT-on
+                        all_variants = set()
+                        for val in col.type.enums:
+                            all_variants.add(val)
+                            all_variants.add(val.lower())
+                            all_variants.add(val.upper())
+                        
+                        labels = ", ".join([f"'{l}'" for l in sorted(list(all_variants))])
+                        print(f"➕ Creating Enum {schema}.{enum_name} with variants...")
+                        connection.execute(text(f'CREATE TYPE "{schema}"."{enum_name}" AS ENUM ({labels})'))
+
+        # 3. TÁBLÁK ÉS OSZLOPOK SZINKRONIZÁLÁSA
+        db_tables_cache = {s: inspector.get_table_names(schema=s) for s in schemas}
+        db_tables_cache[None] = inspector.get_table_names()
+
+        for table in Base.metadata.sorted_tables:
+            if table.name not in db_tables_cache.get(table.schema, []):
+                print(f"❌ Missing table: {table.schema}.{table.name}")
+                if apply:
+                    try:
+                        connection.execute(CreateTable(table))
+                        print(f"✅ Table {table.schema}.{table.name} created.")
+                    except Exception as e:
+                        print(f"🔥 Error creating {table.name}: {e}")
+                continue
+
+            # Oszlop szinkronizálás
+            db_cols = {c['name']: c for c in inspector.get_columns(table.name, schema=table.schema)}
+            for col in table.columns:
+                if col.name not in db_cols:
+                    col_type = col.type.compile(dialect=connection.dialect)
+                    sql = f'ALTER TABLE "{table.schema}"."{table.name}" ADD COLUMN "{col.name}" {col_type}'
+                    if not col.nullable: sql += " NOT NULL"
+                    
+                    if col.default is not None:
+                        arg = col.default.arg
+                        if callable(arg):
+                            if "uuid" in col.name.lower(): sql += " DEFAULT gen_random_uuid()"
+                            elif "now" in str(arg).lower(): sql += " DEFAULT NOW()"
+                        elif isinstance(arg, enum.Enum):
+                            sql += f" DEFAULT '{arg.value}'"
+                        else:
+                            val = f"'{arg}'" if isinstance(arg, str) else arg
+                            sql += f" DEFAULT {val}"
+                    
+                    print(f"⚠️ Adding column: {table.schema}.{table.name}.{col.name}")
+                    if apply: connection.execute(text(sql))
+
+        print("\n--- ✅ Synchronization cycle 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()
+    parser.add_argument('--apply', action='store_true')
+    args = parser.parse_args()
+    dynamic_import_models()
+    await compare_and_repair(apply=args.apply)
+    print("\n✨ Minden tábla és típus szinkronizálva!")
+
+if __name__ == "__main__":
+    asyncio.run(main())

backend/app/scripts/unified_db_sync_1.0.py

@@ -0,0 +1,232 @@
+#!/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())

backend/app/services/analytics_service.py

@@ -0,0 +1,441 @@
+# /opt/docker/dev/service_finder/backend/app/services/analytics_service.py
+"""
+TCO (Total Cost of Ownership) Analytics Service.
+Számítások a vehicle.costs tábla alapján, árfolyam-átváltással a system_service segítségével.
+"""
+
+import logging
+from typing import Optional, Dict, Any, List
+from sqlalchemy import select, func, and_
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.models.vehicle import VehicleCost, CostCategory
+from app.models.vehicle_definitions import VehicleModelDefinition
+from app.models.organization import Organization
+from app.services.system_service import SystemService
+
+logger = logging.getLogger(__name__)
+
+
+class TCOAnalytics:
+    """
+    TCO Analytics osztály 3 fő metódussal:
+    1. get_user_tco: Egy adott organization_id költségeinek összesítése
+    2. get_vehicle_lifetime_tco: Egy jármű összes tulajdonos költségének összesítése (anonimizálva)
+    3. get_global_benchmark: Egy modell (vehicle_model_id) átlagos költségeinek számítása
+    """
+
+    def __init__(self):
+        self.system_service = SystemService()
+
+    async def get_user_tco(
+        self,
+        db: AsyncSession,
+        organization_id: int,
+        currency_target: str = "HUF",
+        include_categories: Optional[List[str]] = None,
+        start_date: Optional[str] = None,
+        end_date: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Egy adott szervezet (organization_id) összes költségének összesítése.
+        Átváltja a különböző valutákban lévő költségeket a célvalutára (currency_target).
+        
+        :param db: Adatbázis munkamenet
+        :param organization_id: A szervezet azonosítója
+        :param currency_target: Célvaluta (pl. "HUF", "EUR")
+        :param include_categories: Szűrés költségkategóriákra (opcionális)
+        :param start_date: Kezdő dátum (ISO formátum, opcionális)
+        :param end_date: Végdátum (ISO formátum, opcionális)
+        :return: Szótár a következőkkel:
+            - total_amount: Összesített összeg a célvalutában
+            - total_transactions: Tranzakciók száma
+            - by_category: Kategóriánkénti bontás
+            - currency: A célvaluta
+        """
+        # Alap lekérdezés: organization_id szűrés
+        stmt = select(
+            VehicleCost.amount,
+            VehicleCost.currency,
+            VehicleCost.category_id,
+            CostCategory.code,
+            CostCategory.name
+        ).join(
+            CostCategory, VehicleCost.category_id == CostCategory.id
+        ).where(
+            VehicleCost.organization_id == organization_id
+        )
+        
+        # Dátum szűrés
+        if start_date:
+            stmt = stmt.where(VehicleCost.date >= start_date)
+        if end_date:
+            stmt = stmt.where(VehicleCost.date <= end_date)
+        
+        # Kategória szűrés
+        if include_categories:
+            stmt = stmt.where(CostCategory.code.in_(include_categories))
+        
+        result = await db.execute(stmt)
+        rows = result.all()
+        
+        # Árfolyamok lekérése a system_service-ből
+        exchange_rates = await self._get_exchange_rates(db, currency_target)
+        
+        total_amount = 0.0
+        category_totals = {}
+        
+        for row in rows:
+            amount = float(row.amount)
+            source_currency = row.currency
+            
+            # Átváltás célvalutára
+            converted_amount = await self._convert_currency(
+                db, amount, source_currency, currency_target, exchange_rates
+            )
+            
+            total_amount += converted_amount
+            
+            # Kategória összesítés
+            category_code = row.code
+            if category_code not in category_totals:
+                category_totals[category_code] = {
+                    "name": row.name,
+                    "total": 0.0,
+                    "count": 0
+                }
+            category_totals[category_code]["total"] += converted_amount
+            category_totals[category_code]["count"] += 1
+        
+        return {
+            "organization_id": organization_id,
+            "total_amount": round(total_amount, 2),
+            "total_transactions": len(rows),
+            "currency": currency_target,
+            "by_category": category_totals,
+            "date_range": {
+                "start": start_date,
+                "end": end_date
+            }
+        }
+
+    async def get_vehicle_lifetime_tco(
+        self,
+        db: AsyncSession,
+        vehicle_model_id: int,
+        currency_target: str = "HUF",
+        anonymize: bool = True,
+    ) -> Dict[str, Any]:
+        """
+        Egy jármű (vehicle_model_id) összes tulajdonos általi költségének összesítése.
+        Alapértelmezetten anonimizálva (organization_id-k elrejtve).
+        
+        :param db: Adatbázis munkamenet
+        :param vehicle_model_id: A járműmodell azonosítója
+        :param currency_target: Célvaluta (pl. "HUF", "EUR")
+        :param anonymize: Ha True, nem tartalmazza az organization_id-kat
+        :return: Szótár a következőkkel:
+            - vehicle_model_id: A járműmodell azonosítója
+            - total_lifetime_cost: Teljes élettartam költség a célvalutában
+            - total_owners: Különböző tulajdonosok száma
+            - average_cost_per_owner: Tulajdonosonkénti átlag
+            - by_owner: Tulajdonosonkénti bontás (ha anonymize=False)
+            - currency: A célvaluta
+        """
+        # Összes költség lekérdezése a járműhöz
+        stmt = select(
+            VehicleCost.amount,
+            VehicleCost.currency,
+            VehicleCost.organization_id,
+            Organization.name.label("org_name")
+        ).outerjoin(
+            Organization, VehicleCost.organization_id == Organization.id
+        ).where(
+            VehicleCost.vehicle_id == vehicle_model_id
+        )
+        
+        result = await db.execute(stmt)
+        rows = result.all()
+        
+        # Árfolyamok lekérése
+        exchange_rates = await self._get_exchange_rates(db, currency_target)
+        
+        total_lifetime_cost = 0.0
+        owners = set()
+        owner_totals = {}
+        
+        for row in rows:
+            amount = float(row.amount)
+            source_currency = row.currency
+            
+            # Átváltás célvalutára
+            converted_amount = await self._convert_currency(
+                db, amount, source_currency, currency_target, exchange_rates
+            )
+            
+            total_lifetime_cost += converted_amount
+            
+            # Tulajdonos adatok
+            org_id = row.organization_id
+            if org_id:
+                owners.add(org_id)
+                
+                if not anonymize:
+                    if org_id not in owner_totals:
+                        owner_totals[org_id] = {
+                            "name": row.org_name,
+                            "total": 0.0,
+                            "count": 0
+                        }
+                    owner_totals[org_id]["total"] += converted_amount
+                    owner_totals[org_id]["count"] += 1
+        
+        total_owners = len(owners)
+        average_cost_per_owner = round(total_lifetime_cost / max(total_owners, 1), 2)
+        
+        result_data = {
+            "vehicle_model_id": vehicle_model_id,
+            "total_lifetime_cost": round(total_lifetime_cost, 2),
+            "total_owners": total_owners,
+            "average_cost_per_owner": average_cost_per_owner,
+            "currency": currency_target,
+            "anonymized": anonymize,
+        }
+        
+        if not anonymize:
+            result_data["by_owner"] = owner_totals
+        
+        return result_data
+
+    async def get_global_benchmark(
+        self,
+        db: AsyncSession,
+        vehicle_model_id: Optional[int] = None,
+        make: Optional[str] = None,
+        model: Optional[str] = None,
+        fuel_type: Optional[str] = None,
+        currency_target: str = "HUF",
+    ) -> Dict[str, Any]:
+        """
+        Egy modell (vehicle_model_id) vagy modellcsoport átlagos költségeinek számítása.
+        Ha vehicle_model_id nincs megadva, akkor make/model/fuel_type alapján csoportosít.
+        
+        :param db: Adatbázis munkamenet
+        :param vehicle_model_id: Konkrét járműmodell azonosítója (opcionális)
+        :param make: Gyártó (opcionális)
+        :param model: Modell (opcionális)
+        :param fuel_type: Üzemanyag típus (opcionális)
+        :param currency_target: Célvaluta (pl. "HUF", "EUR")
+        :return: Szótár a következőkkel:
+            - benchmark_type: "specific_model" vagy "grouped"
+            - vehicle_count: Járművek száma a mintában
+            - total_cost_sum: Összes költség a célvalutában
+            - average_cost_per_vehicle: Járművenkénti átlag
+            - average_cost_per_km: Kilométerenkénti átlag (ha elérhető odometer adat)
+            - by_category: Kategóriánkénti átlagok
+            - currency: A célvaluta
+        """
+        # Alap lekérdezés: vehicle és cost összekapcsolása
+        stmt = select(
+            VehicleCost.amount,
+            VehicleCost.currency,
+            VehicleCost.vehicle_id,
+            VehicleCost.odometer,
+            CostCategory.code,
+            VehicleModelDefinition.make,
+            VehicleModelDefinition.model,
+            VehicleModelDefinition.fuel_type
+        ).join(
+            VehicleModelDefinition, VehicleCost.vehicle_id == VehicleModelDefinition.id
+        ).join(
+            CostCategory, VehicleCost.category_id == CostCategory.id
+        )
+        
+        # Szűrés
+        if vehicle_model_id:
+            stmt = stmt.where(VehicleCost.vehicle_id == vehicle_model_id)
+            benchmark_type = "specific_model"
+        else:
+            conditions = []
+            if make:
+                conditions.append(VehicleModelDefinition.make == make)
+            if model:
+                conditions.append(VehicleModelDefinition.model == model)
+            if fuel_type:
+                conditions.append(VehicleModelDefinition.fuel_type == fuel_type)
+            
+            if conditions:
+                stmt = stmt.where(and_(*conditions))
+            
+            benchmark_type = "grouped"
+        
+        result = await db.execute(stmt)
+        rows = result.all()
+        
+        if not rows:
+            return {
+                "benchmark_type": benchmark_type,
+                "vehicle_count": 0,
+                "total_cost_sum": 0.0,
+                "average_cost_per_vehicle": 0.0,
+                "average_cost_per_km": None,
+                "by_category": {},
+                "currency": currency_target,
+                "message": "No data found for the specified criteria"
+            }
+        
+        # Árfolyamok
+        exchange_rates = await self._get_exchange_rates(db, currency_target)
+        
+        total_cost_sum = 0.0
+        total_odometer_sum = 0
+        vehicle_ids = set()
+        category_totals = {}
+        category_counts = {}
+        
+        for row in rows:
+            amount = float(row.amount)
+            source_currency = row.currency
+            
+            # Átváltás
+            converted_amount = await self._convert_currency(
+                db, amount, source_currency, currency_target, exchange_rates
+            )
+            
+            total_cost_sum += converted_amount
+            vehicle_ids.add(row.vehicle_id)
+            
+            # Odometer összegzés (ha van)
+            if row.odometer:
+                total_odometer_sum += row.odometer
+            
+            # Kategória összesítés
+            category_code = row.code
+            if category_code not in category_totals:
+                category_totals[category_code] = 0.0
+                category_counts[category_code] = 0
+            
+            category_totals[category_code] += converted_amount
+            category_counts[category_code] += 1
+        
+        vehicle_count = len(vehicle_ids)
+        average_cost_per_vehicle = round(total_cost_sum / vehicle_count, 2)
+        
+        # Kilométerenkénti átlag számítása
+        average_cost_per_km = None
+        if total_odometer_sum > 0:
+            average_cost_per_km = round(total_cost_sum / total_odometer_sum, 4)
+        
+        # Kategóriánkénti átlagok
+        category_averages = {}
+        for code, total in category_totals.items():
+            count = category_counts[code]
+            category_averages[code] = {
+                "total": round(total, 2),
+                "count": count,
+                "average": round(total / count, 2)
+            }
+        
+        return {
+            "benchmark_type": benchmark_type,
+            "vehicle_count": vehicle_count,
+            "total_cost_sum": round(total_cost_sum, 2),
+            "average_cost_per_vehicle": average_cost_per_vehicle,
+            "average_cost_per_km": average_cost_per_km,
+            "by_category": category_averages,
+            "currency": currency_target,
+            "criteria": {
+                "vehicle_model_id": vehicle_model_id,
+                "make": make,
+                "model": model,
+                "fuel_type": fuel_type
+            }
+        }
+
+    async def _get_exchange_rates(
+        self,
+        db: AsyncSession,
+        target_currency: str
+    ) -> Dict[str, float]:
+        """
+        Árfolyamok lekérése a system_service-ből.
+        A rendszerparaméterekben az "exchange_rates" kulcs alatt tároljuk.
+        
+        :param db: Adatbázis munkamenet
+        :param target_currency: Célvaluta
+        :return: Szótár forrásvaluta -> célvaluta árfolyammal
+        """
+        exchange_rates = await self.system_service.get_scoped_parameter(
+            db, 
+            key="exchange_rates",
+            default={}
+        )
+        
+        # Ha nincs adat, alapértelmezett árfolyamok
+        if not exchange_rates:
+            logger.warning("No exchange rates found in system parameters, using defaults")
+            # Alapértelmezett árfolyamok (1 EUR = 400 HUF, 1 USD = 350 HUF stb.)
+            exchange_rates = {
+                "EUR": {"HUF": 400.0, "EUR": 1.0, "USD": 1.1},
+                "USD": {"HUF": 350.0, "EUR": 0.9, "USD": 1.0},
+                "HUF": {"HUF": 1.0, "EUR": 0.0025, "USD": 0.0029},
+                "GBP": {"HUF": 460.0, "EUR": 1.15, "USD": 1.26},
+            }
+        
+        # Ellenőrizzük, hogy a célvaluta szerepel-e az árfolyamokban
+        if target_currency not in exchange_rates.get("EUR", {}):
+            logger.warning(f"Target currency {target_currency} not found in exchange rates, using 1:1 conversion")
+        
+        return exchange_rates
+
+    async def _convert_currency(
+        self,
+        db: AsyncSession,
+        amount: float,
+        source_currency: str,
+        target_currency: str,
+        exchange_rates: Dict[str, Any]
+    ) -> float:
+        """
+        Pénznem átváltása a megadott árfolyamok alapján.
+        
+        :param amount: Összeg a forrásvalutában
+        :param source_currency: Forrásvaluta (pl. "EUR")
+        :param target_currency: Célvaluta (pl. "HUF")
+        :param exchange_rates: Árfolyam szótár
+        :return: Átváltott összeg a célvalutában
+        """
+        if source_currency == target_currency:
+            return amount
+        
+        # Keresés az árfolyamokban
+        try:
+            # Próbáljuk meg a forrásvaluta -> célvaluta árfolyamot
+            if source_currency in exchange_rates:
+                rates = exchange_rates[source_currency]
+                if target_currency in rates:
+                    rate = rates[target_currency]
+                    return amount * rate
+            
+            # Ha nem találjuk, próbáljuk meg fordítva (inverz)
+            if target_currency in exchange_rates:
+                rates = exchange_rates[target_currency]
+                if source_currency in rates:
+                    rate = 1.0 / rates[source_currency]
+                    return amount * rate
+            
+            # Ha még mindig nem találjuk, használjunk EUR-t közvetítőként
+            if "EUR" in exchange_rates:
+                eur_rates = exchange_rates["EUR"]
+                if source_currency in eur_rates and target_currency in eur_rates:
+                    # Forrás -> EUR -> Cél
+                    to_eur = amount / eur_rates[source_currency]
+                    return to_eur * eur_rates[target_currency]
+        
+        except (KeyError, ZeroDivisionError, TypeError) as e:
+            logger.error(f"Currency conversion error: {e}, using 1:1 conversion")
+        
+        # Visszaesés: 1:1 árfolyam
+        logger.warning(f"Could not convert {source_currency} to {target_currency}, using 1:1 conversion")
+        return amount

backend/app/services/deduplication_service.py

@@ -0,0 +1,183 @@
+"""
+DeduplicationService - Explicit deduplikáció a márka, technikai kód és jármű típus alapján.
+Integrálja a mapping_rules.py és mapping_dictionary.py fájlokat.
+"""
+import logging
+from typing import Optional, Dict, Any
+from sqlalchemy import select, and_, or_
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.vehicle_definitions import VehicleModelDefinition
+from app.workers.vehicle.mapping_rules import SOURCE_MAPPINGS, unify_data
+
+logger = logging.getLogger(__name__)
+
+# Ha nincs mapping_dictionary, hozzunk létre egy egyszerű szinonima szótárt
+MAPPING_DICTIONARY = {
+    "make_synonyms": {
+        "BMW": ["BMW", "Bayerische Motoren Werke"],
+        "MERCEDES": ["MERCEDES", "MERCEDES-BENZ", "MERCEDES BENZ"],
+        "VOLKSWAGEN": ["VOLKSWAGEN", "VW"],
+        "AUDI": ["AUDI"],
+        "TOYOTA": ["TOYOTA"],
+        "FORD": ["FORD"],
+        # További márkák...
+    },
+    "technical_code_synonyms": {
+        # Példa: "1.8 TSI" -> ["1.8 TSI", "1.8TSI", "1.8 TSI 180"]
+    },
+    "vehicle_class_synonyms": {
+        "SUV": ["SUV", "SPORT UTILITY VEHICLE"],
+        "SEDAN": ["SEDAN", "SALOON"],
+        "HATCHBACK": ["HATCHBACK", "HATCH"],
+        "COUPE": ["COUPE", "COUPÉ"],
+    }
+}
+
+class DeduplicationService:
+    """Szolgáltatás a duplikált járműmodell rekordok azonosítására és kezelésére."""
+    
+    @staticmethod
+    def normalize_make(make: str) -> str:
+        """Normalizálja a márka nevet a szinonimák alapján."""
+        make_upper = make.strip().upper()
+        for canonical, synonyms in MAPPING_DICTIONARY["make_synonyms"].items():
+            if make_upper in synonyms or make_upper == canonical:
+                return canonical
+        return make_upper
+    
+    @staticmethod
+    def normalize_technical_code(technical_code: Optional[str]) -> str:
+        """Normalizálja a technikai kódot (pl. motor kód)."""
+        if not technical_code:
+            return ""
+        # Egyszerű whitespace és pont eltávolítás
+        code = technical_code.strip().upper()
+        # További normalizáció: eltávolítás speciális karakterek
+        import re
+        code = re.sub(r'[^A-Z0-9]', '', code)
+        return code
+    
+    @staticmethod
+    def normalize_vehicle_class(vehicle_class: Optional[str]) -> str:
+        """Normalizálja a jármű osztályt."""
+        if not vehicle_class:
+            return ""
+        class_upper = vehicle_class.strip().upper()
+        for canonical, synonyms in MAPPING_DICTIONARY["vehicle_class_synonyms"].items():
+            if class_upper in synonyms or class_upper == canonical:
+                return canonical
+        return class_upper
+    
+    @classmethod
+    async def find_duplicate(
+        cls,
+        session: AsyncSession,
+        make: str,
+        technical_code: str,
+        vehicle_class: str,
+        exclude_id: Optional[int] = None
+    ) -> Optional[VehicleModelDefinition]:
+        """
+        Megkeresi, hogy létezik-e már ugyanilyen (normalizált) rekord a vehicle_model_definitions táblában.
+        
+        Args:
+            session: SQLAlchemy async session
+            make: márka (pl. "BMW")
+            technical_code: technikai kód (pl. "N47")
+            vehicle_class: jármű osztály (pl. "SEDAN")
+            exclude_id: kizárni kívánt rekord ID (pl. frissítésnél)
+        
+        Returns:
+            VehicleModelDefinition instance ha talált duplikátumot, egyébként None.
+        """
+        norm_make = cls.normalize_make(make)
+        norm_technical_code = cls.normalize_technical_code(technical_code)
+        norm_vehicle_class = cls.normalize_vehicle_class(vehicle_class)
+        
+        # Keresés a normalizált értékek alapján
+        stmt = select(VehicleModelDefinition).where(
+            and_(
+                VehicleModelDefinition.make.ilike(f"%{norm_make}%"),
+                VehicleModelDefinition.technical_code.ilike(f"%{norm_technical_code}%"),
+                VehicleModelDefinition.vehicle_class.ilike(f"%{norm_vehicle_class}%")
+            )
+        )
+        if exclude_id:
+            stmt = stmt.where(VehicleModelDefinition.id != exclude_id)
+        
+        result = await session.execute(stmt)
+        duplicate = result.scalar_one_or_none()
+        
+        if duplicate:
+            logger.info(f"Duplikátum találva: ID {duplicate.id} - {duplicate.make} {duplicate.technical_code} {duplicate.vehicle_class}")
+        return duplicate
+    
+    @classmethod
+    async def ensure_no_duplicate(
+        cls,
+        session: AsyncSession,
+        make: str,
+        technical_code: str,
+        vehicle_class: str,
+        exclude_id: Optional[int] = None
+    ) -> bool:
+        """
+        Ellenőrzi, hogy nincs-e duplikátum. Ha van, False-t ad vissza.
+        """
+        duplicate = await cls.find_duplicate(session, make, technical_code, vehicle_class, exclude_id)
+        return duplicate is None
+    
+    @classmethod
+    async def deduplicate_and_merge(
+        cls,
+        session: AsyncSession,
+        new_record: Dict[str, Any],
+        source_name: str = "manual"
+    ) -> Dict[str, Any]:
+        """
+        Duplikáció ellenőrzése és esetleges merge logika.
+        Ha talál duplikátumot, visszaadja a meglévő rekord adatait.
+        Ha nem, visszaadja a normalizált új rekordot.
+        
+        Args:
+            session: SQLAlchemy async session
+            new_record: új rekord adatai (make, technical_code, vehicle_class, stb.)
+            source_name: adatforrás neve a mapping_rules-hoz
+        
+        Returns:
+            Dict with keys:
+                - is_duplicate: bool
+                - existing_id: int if duplicate else None
+                - normalized_data: normalizált adatok
+        """
+        # Normalizálás mapping_rules segítségével
+        unified = unify_data(new_record, source_name)
+        
+        make = unified.get("normalized_make", new_record.get("make", ""))
+        technical_code = new_record.get("technical_code", "")
+        vehicle_class = new_record.get("vehicle_class", "")
+        
+        duplicate = await cls.find_duplicate(session, make, technical_code, vehicle_class)
+        
+        if duplicate:
+            return {
+                "is_duplicate": True,
+                "existing_id": duplicate.id,
+                "normalized_data": {
+                    "make": duplicate.make,
+                    "technical_code": duplicate.technical_code,
+                    "vehicle_class": duplicate.vehicle_class,
+                }
+            }
+        
+        # Nincs duplikátum, normalizált adatokkal tér vissza
+        return {
+            "is_duplicate": False,
+            "existing_id": None,
+            "normalized_data": {
+                "make": cls.normalize_make(make),
+                "technical_code": cls.normalize_technical_code(technical_code),
+                "vehicle_class": cls.normalize_vehicle_class(vehicle_class),
+            }
+        }

backend/app/services/financial_interfaces.py

@@ -0,0 +1,187 @@
+"""
+Financial Interfaces - Absztrakt alaposztályok a fizetési és számlázási szolgáltatásokhoz.
+
+Ez a modul definiálja a kötelező interfészeket, amelyeket minden konkrét implementációnak
+követnie kell a fizetési átjárók és számlázási szolgáltatások esetében.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional, Dict, Any
+from decimal import Decimal
+
+
+class BasePaymentGateway(ABC):
+    """
+    Absztrakt osztály fizetési átjárók számára.
+    
+    Minden fizetési szolgáltató (Stripe, PayPal, stb.) implementálja ezt az interfészt,
+    hogy a FinancialOrchestrator egységesen kezelhesse őket.
+    """
+    
+    @abstractmethod
+    async def create_intent(
+        self,
+        amount: Decimal,
+        currency: str = "HUF",
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Fizetési szándék létrehozása a külső szolgáltatónál.
+        
+        Args:
+            amount: A fizetendő összeg
+            currency: Pénznem (alapértelmezett: HUF)
+            metadata: Egyéni metaadatok
+            **kwargs: További paraméterek a konkrét implementáció számára
+            
+        Returns:
+            Szótár a fizetési szándék adataival (pl. client_secret, id, status)
+            
+        Raises:
+            PaymentGatewayError: Ha a fizetési szándék létrehozása sikertelen
+        """
+        pass
+    
+    @abstractmethod
+    async def verify_payment(
+        self,
+        payment_intent_id: str,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Fizetés státuszának ellenőrzése a külső szolgáltatónál.
+        
+        Args:
+            payment_intent_id: A fizetési szándék azonosítója
+            **kwargs: További paraméterek
+            
+        Returns:
+            Szótár a fizetés részleteivel (pl. status, amount, customer)
+            
+        Raises:
+            PaymentGatewayError: Ha az ellenőrzés sikertelen
+        """
+        pass
+    
+    @abstractmethod
+    async def refund_payment(
+        self,
+        payment_intent_id: str,
+        amount: Optional[Decimal] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Fizetés visszatérítése.
+        
+        Args:
+            payment_intent_id: A fizetési szándék azonosítója
+            amount: Visszatérítendő összeg (ha None, akkor teljes összeg)
+            **kwargs: További paraméterek
+            
+        Returns:
+            Szótár a visszatérítés részleteivel
+            
+        Raises:
+            PaymentGatewayError: Ha a visszatérítés sikertelen
+        """
+        pass
+
+
+class BaseInvoicingService(ABC):
+    """
+    Absztrakt osztály számlázási szolgáltatások számára.
+    
+    Minden számlázási rendszer (számlázz.hu, NAV Online Számla, stb.) implementálja
+    ezt az interfészt a számlák egységes kezeléséhez.
+    """
+    
+    @abstractmethod
+    async def issue_invoice(
+        self,
+        issuer_id: int,
+        customer_data: Dict[str, Any],
+        items: list[Dict[str, Any]],
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Szála kiállítása.
+        
+        Args:
+            issuer_id: A számlakiállító (Issuer) azonosítója
+            customer_data: Ügyfél adatok (név, cím, adószám, stb.)
+            items: Számla tételek listája
+            **kwargs: További paraméterek
+            
+        Returns:
+            Szótár a számla részleteivel (pl. invoice_number, issue_date, total_amount)
+            
+        Raises:
+            InvoicingError: Ha a számla kiállítása sikertelen
+        """
+        pass
+    
+    @abstractmethod
+    async def get_invoice_status(
+        self,
+        invoice_id: str,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Számla státuszának lekérdezése.
+        
+        Args:
+            invoice_id: A számla azonosítója
+            **kwargs: További paraméterek
+            
+        Returns:
+            Szótár a számla státuszával és további adatokkal
+            
+        Raises:
+            InvoicingError: Ha a státusz lekérdezése sikertelen
+        """
+        pass
+    
+    @abstractmethod
+    async def cancel_invoice(
+        self,
+        invoice_id: str,
+        reason: Optional[str] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Számla érvénytelenítése.
+        
+        Args:
+            invoice_id: A számla azonosítója
+            reason: Érvénytelenítés oka
+            **kwargs: További paraméterek
+            
+        Returns:
+            Szótár az érvénytelenítés eredményével
+            
+        Raises:
+            InvoicingError: Ha az érvénytelenítés sikertelen
+        """
+        pass
+
+
+# Egyéni kivételek a finanszírozási szolgáltatásokhoz
+class FinancialServiceError(Exception):
+    """Alap kivétel az összes finanszírozási szolgáltatási hibához."""
+    pass
+
+
+class PaymentGatewayError(FinancialServiceError):
+    """Kivétel fizetési átjáró hibákhoz."""
+    pass
+
+
+class InvoicingError(FinancialServiceError):
+    """Kivétel számlázási hibákhoz."""
+    pass
+
+
+class InsufficientFundsError(FinancialServiceError):
+    """Kivétel elégtelen egyenleg esetén."""
+    pass

backend/app/services/financial_orchestrator.py

@@ -0,0 +1,449 @@
+"""
+Financial Orchestrator - Unit of Work mintával a pénzügyi tranzakciók atomi kezeléséhez.
+
+Ez a szolgáltatás koordinálja a fizetési folyamatokat, a számlázást és a pénztárca
+műveleteket egyetlen atomi tranzakcióban (Unit of Work minta).
+
+Kulcsfontosságú funkciók:
+1. Vetésforgó (select_issuer) - kiválasztja a megfelelő számlakiállítót
+2. Unit of Work - minden adatbázis művelet egy tranzakcióban
+3. Hibatűrés - rollback hiba esetén
+"""
+
+import logging
+from decimal import Decimal
+from typing import Optional, Dict, Any
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, update, and_
+
+from app.models.audit import FinancialLedger, WalletType, LedgerStatus, LedgerEntryType
+from app.models.identity import Wallet
+from app.models.finance import Issuer, IssuerType
+from app.services.financial_interfaces import (
+    BasePaymentGateway, BaseInvoicingService,
+    PaymentGatewayError, InvoicingError, InsufficientFundsError
+)
+
+logger = logging.getLogger(__name__)
+
+
+class FinancialOrchestrator:
+    """
+    Pénzügyi tranzakciók koordinálója Unit of Work mintával.
+    
+    Ez az osztály felelős a következőkért:
+    - Számlakiállító kiválasztása (vetésforgó logika)
+    - FinancialLedger bejegyzés létrehozása
+    - Pénztárca egyenleg frissítése
+    - Tranzakció atomi végrehajtása (commit/rollback)
+    """
+    
+    def __init__(
+        self,
+        payment_gateway: Optional[BasePaymentGateway] = None,
+        invoicing_service: Optional[BaseInvoicingService] = None
+    ):
+        """
+        Inicializálás opcionális külső szolgáltatásokkal.
+        
+        Args:
+            payment_gateway: Fizetési átjáró implementáció (pl. Stripe)
+            invoicing_service: Számlázási szolgáltatás implementáció
+        """
+        self.payment_gateway = payment_gateway
+        self.invoicing_service = invoicing_service
+    
+    async def select_issuer(
+        self,
+        db: AsyncSession,
+        amount: Decimal,
+        is_company: bool = False
+    ) -> Issuer:
+        """
+        Vetésforgó logika: kiválasztja a megfelelő számlakiállítót.
+        
+        Logika:
+        1. Keressen egy aktív 'EV' típusú Issuert
+        2. Ha az `current_revenue + amount < revenue_limit` ÉS a vevő nem cég
+           (`is_company == False`), térjen vissza az EV-vel
+        3. Minden más esetben térjen vissza az aktív 'KFT' típusú Issuerrel
+        
+        Args:
+            db: Adatbázis munkamenet
+            amount: A tranzakció összege
+            is_company: A vevő cég-e (True esetén nem választható EV)
+            
+        Returns:
+            A kiválasztott Issuer objektum
+            
+        Raises:
+            ValueError: Ha nincs aktív számlakiállító
+        """
+        # 1. EV típusú aktív számlakiállító keresése
+        ev_query = select(Issuer).where(
+            and_(
+                Issuer.type == IssuerType.EV,
+                Issuer.is_active == True
+            )
+        ).order_by(Issuer.id)
+        
+        ev_result = await db.execute(ev_query)
+        ev_issuer_obj = ev_result.scalars().first()
+        
+        logger.debug(f"EV számlakiállító keresés: talált={ev_issuer_obj is not None}, is_company={is_company}")
+        
+        # 2. Ellenőrizzük, hogy az EV használható-e
+        if ev_issuer_obj and not is_company:
+            # Számoljuk ki az új bevételt
+            new_revenue = ev_issuer_obj.current_revenue + amount
+            logger.debug(f"EV ellenőrzés: current_revenue={ev_issuer_obj.current_revenue}, amount={amount}, new_revenue={new_revenue}, limit={ev_issuer_obj.revenue_limit}")
+            if new_revenue < ev_issuer_obj.revenue_limit:
+                logger.info(f"EV számlakiállító kiválasztva: {ev_issuer_obj.id} "
+                          f"(új bevétel: {new_revenue}, limit: {ev_issuer_obj.revenue_limit})")
+                return ev_issuer_obj
+            else:
+                logger.debug(f"EV limit túllépve: {new_revenue} >= {ev_issuer_obj.revenue_limit}")
+        
+        # 3. KFT típusú aktív számlakiállító keresése
+        kft_query = select(Issuer).where(
+            and_(
+                Issuer.type == IssuerType.KFT,
+                Issuer.is_active == True
+            )
+        ).order_by(Issuer.id)
+        
+        kft_result = await db.execute(kft_query)
+        kft_issuer_obj = kft_result.scalars().first()
+        
+        logger.debug(f"KFT számlakiállító keresés: talált={kft_issuer_obj is not None}")
+        
+        if kft_issuer_obj:
+            logger.info(f"KFT számlakiállító kiválasztva: {kft_issuer_obj.id}")
+            return kft_issuer_obj
+        
+        # 4. Ha egyik sem található, hiba
+        raise ValueError("Nincs aktív számlakiállító (sem EV, sem KFT)")
+    
+    async def process_payment(
+        self,
+        db: AsyncSession,
+        user_id: int,
+        amount: Decimal,
+        wallet_type: WalletType,
+        description: str = "",
+        metadata: Optional[Dict[str, Any]] = None,
+        is_company: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Fő fizetési folyamat Unit of Work mintával.
+        
+        A folyamat egyetlen nagy try...except...finally blokkban fut:
+        1. Kiválasztja a számlakiállítót (vetésforgó)
+        2. Létrehoz egy bejegyzést a FinancialLedger-ben (PENDING státusszal)
+        3. Frissíti a megfelelő Wallet egyenlegét
+        4. Csak a legvégén hív egyetlen db.commit()-ot
+        5. Hiba esetén KÖTELEZŐ a db.rollback()
+        
+        Args:
+            db: Adatbázis munkamenet
+            user_id: A felhasználó azonosítója
+            amount: A fizetendő összeg (pozitív)
+            wallet_type: A cél pénztárca típusa
+            description: Tranzakció leírása
+            metadata: Egyéni metaadatok
+            is_company: A felhasználó cég-e
+            
+        Returns:
+            Szótár a tranzakció részleteivel
+            
+        Raises:
+            InsufficientFundsError: Ha nincs elég egyenleg
+            PaymentGatewayError: Ha a fizetési átjáró hibát jelez
+            ValueError: Ha érvénytelen paraméterek
+        """
+        if amount <= 0:
+            raise ValueError("Az összegnek pozitívnak kell lennie")
+        
+        # Unit of Work: egyetlen tranzakció
+        try:
+            logger.info(f"Payment process indítása: user={user_id}, amount={amount}, "
+                       f"wallet_type={wallet_type}, is_company={is_company}")
+            
+            # 1. Számlakiállító kiválasztása
+            issuer = await self.select_issuer(db, amount, is_company)
+            logger.info(f"Személyi számlakiállító kiválasztva: {issuer.id} ({issuer.type})")
+            
+            # 2. FinancialLedger bejegyzés létrehozása (PENDING státusszal)
+            ledger_entry = FinancialLedger(
+                user_id=user_id,
+                amount=float(amount),  # Convert Decimal to float for Numeric field
+                wallet_type=wallet_type,
+                status=LedgerStatus.PENDING,
+                issuer_id=issuer.id,
+                entry_type=LedgerEntryType.DEBIT,  # Payment is a DEBIT
+                currency="HUF",  # Default currency
+                transaction_type=description or "Payment via FinancialOrchestrator",
+                details=metadata or {}  # Store metadata in details JSON field
+            )
+            
+            db.add(ledger_entry)
+            await db.flush()  # Megkapjuk az ID-t, de még nincs commit
+            
+            logger.info(f"FinancialLedger bejegyzés létrehozva: {ledger_entry.id}")
+            
+            # 3. Pénztárca egyenleg frissítése
+            # Először lekérjük a pénztárcát zárolással (minden usernek csak egy walletje van)
+            wallet_query = select(Wallet).where(
+                Wallet.user_id == user_id
+            ).with_for_update()  # Sorzárolás a konkurrens hozzáférés megelőzésére
+            
+            wallet_result = await db.execute(wallet_query)
+            wallet = wallet_result.scalar_one_or_none()
+            
+            if not wallet:
+                raise ValueError(f"Nincs pénztárca a user {user_id} számára")
+            
+            # Ellenőrizzük az egyenleget (ha kivételről van szó)
+            # Megjegyzés: A valós implementációban itt ellenőriznénk, hogy van-e elég egyenleg
+            # de a specifikáció szerint csak frissítjük az egyenleget
+            
+            # A Wallet modellben nincs 'balance' mező, hanem külön mezők vannak a különböző credit típusokhoz
+            # Frissítjük a megfelelő credit mezőt a wallet_type alapján
+            # MEGJEGYZÉS: Payment (DEBIT) csökkenti a pénztárca egyenlegét!
+            update_values = {}
+            current_balance = Decimal('0')
+            
+            if wallet_type == WalletType.EARNED:
+                current_balance = Decimal(str(wallet.earned_credits))
+                new_balance = current_balance - amount  # DEBIT csökkenti az egyenleget
+                update_values['earned_credits'] = float(new_balance)
+            elif wallet_type == WalletType.PURCHASED:
+                current_balance = Decimal(str(wallet.purchased_credits))
+                new_balance = current_balance - amount  # DEBIT csökkenti az egyenleget
+                update_values['purchased_credits'] = float(new_balance)
+            elif wallet_type == WalletType.SERVICE_COINS:
+                current_balance = Decimal(str(wallet.service_coins))
+                new_balance = current_balance - amount  # DEBIT csökkenti az egyenleget
+                update_values['service_coins'] = float(new_balance)
+            elif wallet_type == WalletType.VOUCHER:
+                # VOUCHER típusnál nincs dedikált mező a Wallet modellben
+                # Kezeljük mint SERVICE_COINS vagy dobjunk hibát
+                current_balance = Decimal(str(wallet.service_coins))
+                new_balance = current_balance - amount  # DEBIT csökkenti az egyenleget
+                update_values['service_coins'] = float(new_balance)
+                logger.warning(f"VOUCHER wallet_type használva, SERVICE_COINS frissítve")
+            else:
+                raise ValueError(f"Ismeretlen wallet_type: {wallet_type}")
+            
+            # Frissítjük a pénztárcát
+            await db.execute(
+                update(Wallet)
+                .where(Wallet.id == wallet.id)
+                .values(**update_values)
+            )
+            
+            logger.info(f"Pénztárca frissítve: {wallet.id}, wallet_type={wallet_type}, új egyenleg: {new_balance} (korábbi: {current_balance})")
+            
+            # 4. FinancialLedger státusz frissítése SUCCESS-re
+            ledger_entry.status = LedgerStatus.SUCCESS
+            
+            # 5. Számlakiállító bevételének frissítése
+            issuer.current_revenue += amount
+            db.add(issuer)
+            
+            # 6. Külső szolgáltatások meghívása (ha vannak)
+            external_results = {}
+            
+            if self.payment_gateway:
+                try:
+                    payment_result = await self.payment_gateway.create_intent(
+                        amount=amount,
+                        currency="HUF",
+                        metadata={
+                            "ledger_id": ledger_entry.id,
+                            "user_id": user_id,
+                            "issuer_id": issuer.id,
+                            **(metadata or {})
+                        }
+                    )
+                    external_results["payment"] = payment_result
+                    logger.info(f"Fizetési szándék létrehozva: {payment_result.get('id')}")
+                except PaymentGatewayError as e:
+                    logger.error(f"Fizetési átjáró hiba: {e}")
+                    # Döntés: tovább dobjuk a hibát, ami rollback-et okoz
+                    raise
+            
+            if self.invoicing_service:
+                try:
+                    # Ügyfél adatok gyűjtése (egyszerűsített)
+                    customer_data = {
+                        "user_id": user_id,
+                        "amount": float(amount),
+                        "description": description
+                    }
+                    
+                    invoice_result = await self.invoicing_service.issue_invoice(
+                        issuer_id=issuer.id,
+                        customer_data=customer_data,
+                        items=[{
+                            "description": description or "Szolgáltatás díja",
+                            "quantity": 1,
+                            "unit_price": float(amount),
+                            "vat_rate": 27.0  # ÁFA kulcs
+                        }]
+                    )
+                    external_results["invoice"] = invoice_result
+                    logger.info(f"Szála kiállítva: {invoice_result.get('invoice_number')}")
+                except InvoicingError as e:
+                    logger.error(f"Számlázási hiba: {e}")
+                    # Döntés: tovább dobjuk a hibát, ami rollback-et okoz
+                    raise
+            
+            # 7. COMMIT - minden művelet sikeres, atomi mentés
+            await db.commit()
+            logger.info(f"Tranzakció sikeresen commitálva: ledger_id={ledger_entry.id}")
+            
+            # Visszatérési érték
+            return {
+                "success": True,
+                "ledger_id": ledger_entry.id,
+                "issuer_id": issuer.id,
+                "issuer_type": issuer.type,
+                "wallet_id": wallet.id,
+                "new_balance": new_balance,
+                "external_results": external_results,
+                "message": "Payment processed successfully"
+            }
+            
+        except Exception as e:
+            # 8. ROLLBACK - bármilyen hiba esetén
+            logger.error(f"Hiba a tranzakcióban: {e}", exc_info=True)
+            await db.rollback()
+            
+            # Speciális hibák újradobása
+            if isinstance(e, (InsufficientFundsError, PaymentGatewayError, InvoicingError)):
+                raise
+            
+            # Általános hiba
+            raise FinancialOrchestratorError(f"Payment processing failed: {e}") from e
+        
+        finally:
+            # 9. További takarítás (ha szükséges)
+            # Jelenleg nincs extra takarítási logika
+            pass
+    
+    async def refund_payment(
+        self,
+        db: AsyncSession,
+        ledger_id: int,
+        reason: str = ""
+    ) -> Dict[str, Any]:
+        """
+        Visszatérítés folyamata Unit of Work mintával.
+        
+        Ez a metódus visszafordítja egy korábbi tranzakciót:
+        1. Megkeresi az eredeti FinancialLedger bejegyzést
+        2. Létrehoz egy negatív összegű bejegyzést (REFUND státusszal)
+        3. Visszaállítja a pénztárca egyenlegét
+        4. Visszaállítja a számlakiállító bevételét
+        
+        Args:
+            db: Adatbázis munkamenet
+            ledger_id: Az eredeti FinancialLedger bejegyzés azonosítója
+            reason: Visszatérítés oka
+            
+        Returns:
+            Szótár a visszatérítés részleteivel
+        """
+        try:
+            logger.info(f"Visszatérítés indítása: ledger_id={ledger_id}")
+            
+            # 1. Eredeti bejegyzés lekérdezése
+            original_query = select(FinancialLedger).where(
+                FinancialLedger.id == ledger_id
+            ).with_for_update()
+            
+            original_result = await db.execute(original_query)
+            original_entry = original_result.scalar_one_or_none()
+            
+            if not original_entry:
+                raise ValueError(f"Nincs FinancialLedger bejegyzés a következő ID-val: {ledger_id}")
+            
+            if original_entry.status != LedgerStatus.SUCCESS:
+                raise ValueError(f"Csak SUCCESS státuszú bejegyzések téríthetők vissza. "
+                               f"Jelenlegi státusz: {original_entry.status}")
+            
+            # 2. Visszatérítési bejegyzés létrehozása
+            refund_entry = FinancialLedger(
+                user_id=original_entry.user_id,
+                amount=-original_entry.amount,  # Negatív összeg
+                wallet_type=original_entry.wallet_type,
+                status=LedgerStatus.REFUND,
+                issuer_id=original_entry.issuer_id,
+                description=f"Visszatérítés: {reason}" if reason else "Visszatérítés",
+                metadata={
+                    "original_ledger_id": ledger_id,
+                    "reason": reason,
+                    "refund_type": "full"
+                }
+            )
+            
+            db.add(refund_entry)
+            await db.flush()
+            
+            # 3. Pénztárca egyenleg visszaállítása
+            wallet_query = select(Wallet).where(
+                and_(
+                    Wallet.user_id == original_entry.user_id,
+                    Wallet.wallet_type == original_entry.wallet_type
+                )
+            ).with_for_update()
+            
+            wallet_result = await db.execute(wallet_query)
+            wallet = wallet_result.scalar_one_or_none()
+            
+            if wallet:
+                new_balance = wallet.balance - original_entry.amount
+                await db.execute(
+                    update(Wallet)
+                    .where(Wallet.id == wallet.id)
+                    .values(balance=new_balance)
+                )
+            
+            # 4. Számlakiállító bevételének csökkentése
+            issuer_query = select(Issuer).where(Issuer.id == original_entry.issuer_id)
+            issuer_result = await db.execute(issuer_query)
+            issuer = issuer_result.scalar_one()
+            
+            issuer.current_revenue -= original_entry.amount
+            db.add(issuer)
+            
+            # 5. Eredeti bejegyzés státuszának frissítése
+            original_entry.status = LedgerStatus.REFUNDED
+            original_entry.metadata = {
+                **(original_entry.metadata or {}),
+                "refund_ledger_id": refund_entry.id,
+                "refund_reason": reason
+            }
+            
+            # 6. COMMIT
+            await db.commit()
+            
+            logger.info(f"Visszatérítés sikeres: refund_ledger_id={refund_entry.id}")
+            
+            return {
+                "success": True,
+                "refund_ledger_id": refund_entry.id,
+                "original_ledger_id": ledger_id,
+                "amount_refunded": original_entry.amount,
+                "message": "Refund processed successfully"
+            }
+            
+        except Exception as e:
+            logger.error(f"Hiba a visszatérítésben: {e}", exc_info=True)
+            await db.rollback()
+            raise FinancialOrchestratorError(f"Refund processing failed: {e}") from e
+
+
+class FinancialOrchestratorError(Exception):
+    """Kivétel a FinancialOrchestrator hibáinak kezelés"""

backend/app/services/geo_service.py

@@ -28,8 +28,8 @@ class GeoService:
         
         query = text("""
             SELECT DISTINCT s.name 
-            FROM data.geo_streets s
-            JOIN data.geo_postal_codes p ON s.postal_code_id = p.id
+            FROM system.geo_streets s
+            JOIN system.geo_postal_codes p ON s.postal_code_id = p.id
             WHERE p.zip_code = :zip AND s.name ILIKE :q
             ORDER BY s.name ASC LIMIT :limit
         """)
@@ -76,7 +76,7 @@ class GeoService:
 
             # 2. Irányítószám és Város (Auto-learning / Upsert)
             zip_id_query = text("""
-                INSERT INTO data.geo_postal_codes (zip_code, city, country_code) 
+                INSERT INTO system.geo_postal_codes (zip_code, city, country_code)
                 VALUES (:z, :c, :cc)
                 ON CONFLICT (country_code, zip_code, city) DO UPDATE SET city = EXCLUDED.city
                 RETURNING id
@@ -86,13 +86,13 @@ class GeoService:
 
             # 3. Utca szótár frissítése
             await db.execute(text("""
-                INSERT INTO data.geo_streets (postal_code_id, name) VALUES (:zid, :n)
+                INSERT INTO system.geo_streets (postal_code_id, name) VALUES (:zid, :n)
                 ON CONFLICT (postal_code_id, name) DO NOTHING
             """), {"zid": zip_id, "n": street_name})
 
             # 4. Közterület típus (út, utca, köz...)
             await db.execute(text("""
-                INSERT INTO data.geo_street_types (name) VALUES (:n) 
+                INSERT INTO system.geo_street_types (name) VALUES (:n)
                 ON CONFLICT (name) DO NOTHING
             """), {"n": street_type.lower()})
 
@@ -113,7 +113,7 @@ class GeoService:
 
             # 6. Központi Address rekord rögzítése vagy lekérése
             address_query = text("""
-                INSERT INTO data.addresses (
+                INSERT INTO system.addresses (
                     postal_code_id, street_name, street_type, house_number, 
                     stairwell, floor, door, parcel_id, full_address_text
                 )
@@ -135,7 +135,7 @@ class GeoService:
             # 7. Biztonsági keresés: Ha létezett a rekord, de nem kaptunk ID-t a RETURNING-gal
             if not addr_id:
                 lookup_query = text("""
-                    SELECT id FROM data.addresses 
+                    SELECT id FROM system.addresses
                     WHERE postal_code_id = :zid 
                       AND street_name = :sn 
                       AND street_type = :st

backend/app/services/logbook_service.py

@@ -0,0 +1,185 @@
+# /opt/docker/dev/service_finder/backend/app/services/logbook_service.py
+"""
+Logbook Service - GPS, OBDII és előfizetési szűrő kezelése.
+"""
+import logging
+from typing import Optional, Tuple, Any
+from decimal import Decimal
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+
+from app.models.asset import VehicleLogbook
+from app.models.gamification import UserStats
+from app.models.identity import User
+from app.models.system import SystemParameter
+
+logger = logging.getLogger("Logbook-Service-2.0")
+
+class LogbookService:
+    """
+    Útnyilvántartás kezelése GPS koordinátákkal, OBDII adatokkal és előfizetési szintű jogosultságokkal.
+    """
+
+    @staticmethod
+    async def get_system_parameter(db: AsyncSession, key: str, default: Any = None) -> Any:
+        """
+        Lekéri a rendszerparamétert a system.system_parameters táblából.
+        Elsőként a global scope-ot keresi (scope_level='global', scope_id=NULL).
+        Ha nem talál, visszaadja a default értéket.
+        """
+        stmt = select(SystemParameter).where(
+            SystemParameter.key == key,
+            SystemParameter.scope_level == 'global',
+            SystemParameter.scope_id.is_(None),
+            SystemParameter.is_active == True
+        ).order_by(SystemParameter.updated_at.desc())
+        result = await db.execute(stmt)
+        param = result.scalar_one_or_none()
+        if param and 'value' in param.value:
+            return param.value['value']
+        return default
+
+    @staticmethod
+    async def get_user_rank(db: AsyncSession, user_id: int) -> int:
+        """
+        Lekérdezi a felhasználó aktuális rankját (current_level) a UserStats táblából.
+        Ha nincs rekord, alapértelmezett 0 (ingyenes szint).
+        """
+        stmt = select(UserStats.current_level).where(UserStats.user_id == user_id)
+        result = await db.execute(stmt)
+        rank = result.scalar_one_or_none()
+        return rank if rank is not None else 0
+
+    @staticmethod
+    async def check_subscription_guard(
+        db: AsyncSession,
+        user_id: int,
+        wants_gps: bool = False,
+        wants_obd: bool = False
+    ) -> Tuple[bool, str]:
+        """
+        Ellenőrzi, hogy a felhasználó előfizetési szintje engedélyezi-e a GPS/OBDII adatok rögzítését.
+        
+        Szabályok:
+        - Rank >= LOGBOOK_GPS_MIN_RANK (alapértelmezett 50): engedélyezett a GPS távolság és koordináták
+        - Rank >= 90 (VIP/Admin): minden engedélyezett (GPS, OBDII, gyorsulás)
+        - Rank < LOGBOOK_GPS_MIN_RANK: csak manuális distance_km és trip_type rögzíthető
+        
+        Visszatérés: (allowed: bool, message: str)
+        """
+        rank = await LogbookService.get_user_rank(db, user_id)
+        gps_min_rank = await LogbookService.get_system_parameter(db, 'LOGBOOK_GPS_MIN_RANK', 50)
+        vip_min_rank = 90  # Fix VIP küszöb
+        
+        if rank >= vip_min_rank:
+            return True, "VIP/Admin szint: minden adat rögzíthető"
+        
+        if rank >= gps_min_rank:
+            if wants_gps or wants_obd:
+                return True, f"PREMIUM szint (rank {rank} >= {gps_min_rank}): GPS és OBDII adatok rögzíthetők"
+            return True, "PREMIUM szint"
+        
+        # Ingyenes felhasználó
+        if wants_gps or wants_obd:
+            return False, f"Ingyenes felhasználók (rank {rank} < {gps_min_rank}) nem rögzíthetnek GPS koordinátákat vagy OBDII adatokat. Csak manuális distance_km és trip_type engedélyezett."
+        
+        return True, "Ingyenes szint: csak manuális adatok"
+
+    @staticmethod
+    async def create_logbook_entry(
+        db: AsyncSession,
+        asset_id: str,
+        driver_id: int,
+        trip_type: str,
+        start_mileage: int,
+        end_mileage: Optional[int] = None,
+        distance_km: Optional[float] = None,
+        start_lat: Optional[float] = None,
+        start_lng: Optional[float] = None,
+        end_lat: Optional[float] = None,
+        end_lng: Optional[float] = None,
+        gps_calculated_distance: Optional[float] = None,
+        obd_verified: bool = False,
+        max_acceleration: Optional[float] = None,
+        average_speed: Optional[float] = None,
+    ) -> VehicleLogbook:
+        """
+        Új útnyilvántartás bejegyzés létrehozása előfizetési szűrővel.
+        
+        Automatikusan ellenőrzi, hogy a felhasználó rankja engedélyezi-e a GPS/OBDII mezők kitöltését.
+        Ha nem, a GPS és OBDII mezők null-ra állnak, és csak a manuális distance_km marad.
+        """
+        # Ellenőrizzük a jogosultságot
+        wants_gps = any([start_lat, start_lng, end_lat, end_lng, gps_calculated_distance])
+        wants_obd = obd_verified or max_acceleration is not None or average_speed is not None
+        
+        allowed, message = await LogbookService.check_subscription_guard(
+            db, driver_id, wants_gps, wants_obd
+        )
+        
+        if not allowed:
+            # Ha nem engedélyezett, nullázzuk a tiltott mezőket
+            logger.warning(f"User {driver_id} attempted to log GPS/OBDII without permission. {message}")
+            start_lat = start_lng = end_lat = end_lng = gps_calculated_distance = None
+            obd_verified = False
+            max_acceleration = average_speed = None
+        
+        # Új bejegyzés létrehozása
+        new_entry = VehicleLogbook(
+            asset_id=asset_id,
+            driver_id=driver_id,
+            trip_type=trip_type,
+            start_mileage=start_mileage,
+            end_mileage=end_mileage,
+            distance_km=distance_km,
+            start_lat=start_lat,
+            start_lng=start_lng,
+            end_lat=end_lat,
+            end_lng=end_lng,
+            gps_calculated_distance=gps_calculated_distance,
+            obd_verified=obd_verified,
+            max_acceleration=max_acceleration,
+            average_speed=average_speed,
+        )
+        
+        db.add(new_entry)
+        await db.commit()
+        await db.refresh(new_entry)
+        
+        logger.info(f"Logbook entry created for asset {asset_id}, driver {driver_id}, trip_type {trip_type}")
+        return new_entry
+
+    @staticmethod
+    async def calculate_official_distance(
+        start_coords: Tuple[float, float],
+        end_coords: Tuple[float, float]
+    ) -> Optional[float]:
+        """
+        TODO: OSRM/Google Maps API hívással számolja ki a legrövidebb útvonal távolságát.
+        Egyelőre placeholder, később implementálandó.
+        
+        Visszatérés: távolság kilométerben (float) vagy None, ha nem sikerült.
+        """
+        # TODO: Integrálni OSRM vagy Google Maps Distance Matrix API-t
+        # Példa: https://project-osrm.org/docs/v5.24.0/api/#route-service
+        # Jelenleg egyszerű haversine formula alapján számolunk
+        from math import radians, sin, cos, sqrt, atan2
+        
+        lat1, lon1 = start_coords
+        lat2, lon2 = end_coords
+        
+        R = 6371.0  # Föld sugara km-ben
+        
+        lat1_rad = radians(lat1)
+        lon1_rad = radians(lon1)
+        lat2_rad = radians(lat2)
+        lon2_rad = radians(lon2)
+        
+        dlon = lon2_rad - lon1_rad
+        dlat = lat2_rad - lat1_rad
+        
+        a = sin(dlat / 2)**2 + cos(lat1_rad) * cos(lat2_rad) * sin(dlon / 2)**2
+        c = 2 * atan2(sqrt(a), sqrt(1 - a))
+        
+        distance_km = R * c
+        return round(distance_km, 2)

backend/app/services/marketplace_service.py

@@ -0,0 +1,269 @@
+# /opt/docker/dev/service_finder/backend/app/services/marketplace_service.py
+"""
+Marketplace Service – Verifikált Szerviz Értékelések (Social 3) logikája.
+"""
+
+import logging
+import uuid
+import asyncio
+from datetime import datetime, timedelta
+from typing import Optional, Dict, Any, List, Tuple
+from sqlalchemy import select, and_, func
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.exc import IntegrityError
+
+from app.models.social import ServiceReview
+from app.models.service import ServiceProfile
+from app.models.identity import User
+from app.models.audit import FinancialLedger
+from app.models.system import SystemParameter
+from app.schemas.social import ServiceReviewCreate, ServiceReviewResponse
+from app.services.system_service import get_system_parameter
+
+logger = logging.getLogger(__name__)
+
+
+async def create_verified_review(
+    db: AsyncSession,
+    service_id: int,
+    user_id: int,
+    transaction_id: uuid.UUID,
+    review_data: ServiceReviewCreate,
+) -> ServiceReviewResponse:
+    """
+    Verifikált szerviz értékelés létrehozása.
+    Csak igazolt pénzügyi tranzakció után, időablakon belül, egy tranzakcióra egyszer.
+    
+    Args:
+        db: AsyncSession
+        service_id: A szerviz ID (service_profiles.id)
+        user_id: A felhasználó ID (users.id)
+        transaction_id: A pénzügyi tranzakció UUID (financial_ledger.transaction_id)
+        review_data: Értékelési adatok (ratings, comment)
+    
+    Returns:
+        ServiceReviewResponse
+    
+    Raises:
+        ValueError: Ha a validáció sikertelen.
+        IntegrityError: Ha a tranzakció már értékelve van.
+    """
+    # 1. Ellenőrzés: Létezik‑e a szerviz?
+    service = await db.get(ServiceProfile, service_id)
+    if not service:
+        raise ValueError(f"Service {service_id} not found")
+    
+    # 2. Ellenőrzés: Létezik‑e a felhasználó?
+    user = await db.get(User, user_id)
+    if not user:
+        raise ValueError(f"User {user_id} not found")
+    
+    # 3. Ellenőrzés: A tranzakció létezik és a felhasználóhoz tartozik?
+    stmt = select(FinancialLedger).where(
+        FinancialLedger.transaction_id == transaction_id,
+        FinancialLedger.user_id == user_id
+    )
+    result = await db.execute(stmt)
+    transaction = result.scalar_one_or_none()
+    if not transaction:
+        raise ValueError(f"Transaction {transaction_id} not found or does not belong to user {user_id}")
+    
+    # 4. Ellenőrzés: A tranzakció időpontja a REVIEW_WINDOW_DAYS‑on belül van?
+    window_days = await get_system_parameter(db, "REVIEW_WINDOW_DAYS", default=30)
+    window_limit = datetime.now() - timedelta(days=window_days)
+    if transaction.created_at < window_limit:
+        raise ValueError(f"Transaction is older than {window_days} days, review window expired")
+    
+    # 5. Ellenőrzés: Már létezik‑e értékelés ehhez a tranzakcióhoz?
+    existing_review = await db.execute(
+        select(ServiceReview).where(ServiceReview.transaction_id == transaction_id)
+    )
+    if existing_review.scalar_one_or_none():
+        raise IntegrityError(f"Transaction {transaction_id} already has a review")
+    
+    # 6. Értékelési dimenziók validálása (1‑10)
+    ratings = [
+        review_data.price_rating,
+        review_data.quality_rating,
+        review_data.time_rating,
+        review_data.communication_rating
+    ]
+    for rating in ratings:
+        if not (1 <= rating <= 10):
+            raise ValueError("All ratings must be between 1 and 10")
+    
+    # 7. ServiceReview létrehozása
+    review = ServiceReview(
+        service_id=service_id,
+        user_id=user_id,
+        transaction_id=transaction_id,
+        price_rating=review_data.price_rating,
+        quality_rating=review_data.quality_rating,
+        time_rating=review_data.time_rating,
+        communication_rating=review_data.communication_rating,
+        comment=review_data.comment,
+        is_verified=True
+    )
+    db.add(review)
+    await db.commit()
+    await db.refresh(review)
+    
+    # 8. Háttér‑aggregátor indítása (aszinkron)
+    asyncio.create_task(update_service_rating_aggregates(db, service_id))
+    
+    logger.info(f"Verified review created: id={review.id}, service={service_id}, user={user_id}")
+    
+    return ServiceReviewResponse.from_orm(review)
+
+
+async def update_service_rating_aggregates(db: AsyncSession, service_id: int) -> None:
+    """
+    Frissíti a szerviz aggregált értékelési adatait (service_profiles táblában).
+    Ez a függvény háttérben futhat (pl. Celery vagy asyncio task).
+    """
+    # Összes verifikált értékelés lekérdezése a szervizhez
+    stmt = select(
+        func.count(ServiceReview.id).label("count"),
+        func.avg(ServiceReview.price_rating).label("price_avg"),
+        func.avg(ServiceReview.quality_rating).label("quality_avg"),
+        func.avg(ServiceReview.time_rating).label("time_avg"),
+        func.avg(ServiceReview.communication_rating).label("communication_avg"),
+        func.max(ServiceReview.created_at).label("last_review_at")
+    ).where(
+        and_(
+            ServiceReview.service_id == service_id,
+            ServiceReview.is_verified == True
+        )
+    )
+    result = await db.execute(stmt)
+    row = result.fetchone()
+    
+    if not row or row.count == 0:
+        # Nincs értékelés, alapértékek
+        price_avg = quality_avg = time_avg = communication_avg = None
+        count = 0
+        last_review_at = None
+    else:
+        count = row.count
+        price_avg = float(row.price_avg) if row.price_avg else None
+        quality_avg = float(row.quality_avg) if row.quality_avg else None
+        time_avg = float(row.time_avg) if row.time_avg else None
+        communication_avg = float(row.communication_avg) if row.communication_avg else None
+        last_review_at = row.last_review_at
+    
+    # Trust‑score súlyozás: a felhasználók trust‑score‑jának átlaga
+    trust_stmt = select(func.avg(User.trust_score)).join(
+        ServiceReview, ServiceReview.user_id == User.id
+    ).where(
+        and_(
+            ServiceReview.service_id == service_id,
+            ServiceReview.is_verified == True
+        )
+    )
+    trust_result = await db.execute(trust_stmt)
+    avg_trust = trust_result.scalar() or 50.0  # alapérték 50
+    
+    # Trust‑score befolyási tényező
+    trust_factor = await get_system_parameter(db, "TRUST_SCORE_INFLUENCE_FACTOR", default=1.0)
+    trust_weight = 1.0 + (avg_trust / 100.0) * trust_factor
+    
+    # Súlyozott összpontszám számítása
+    weights = await get_system_parameter(db, "REVIEW_RATING_WEIGHTS", default={
+        "price": 0.25,
+        "quality": 0.35,
+        "time": 0.20,
+        "communication": 0.20
+    })
+    weighted_score = 0.0
+    if price_avg:
+        weighted_score += price_avg * weights.get("price", 0.25)
+    if quality_avg:
+        weighted_score += quality_avg * weights.get("quality", 0.35)
+    if time_avg:
+        weighted_score += time_avg * weights.get("time", 0.20)
+    if communication_avg:
+        weighted_score += communication_avg * weights.get("communication", 0.20)
+    
+    weighted_score *= trust_weight
+    
+    # ServiceProfile frissítése
+    service = await db.get(ServiceProfile, service_id)
+    if service:
+        service.rating_verified_count = count
+        service.rating_price_avg = price_avg
+        service.rating_quality_avg = quality_avg
+        service.rating_time_avg = time_avg
+        service.rating_communication_avg = communication_avg
+        service.rating_overall = weighted_score
+        service.last_review_at = last_review_at
+        await db.commit()
+        logger.debug(f"Updated rating aggregates for service {service_id}: count={count}, overall={weighted_score:.2f}")
+
+
+async def get_service_reviews(
+    db: AsyncSession,
+    service_id: int,
+    skip: int = 0,
+    limit: int = 20,
+    verified_only: bool = True
+) -> Tuple[List[ServiceReviewResponse], int]:
+    """
+    Szerviz értékeléseinek lapozható listázása.
+    
+    Args:
+        db: AsyncSession
+        service_id: A szerviz ID
+        skip: Lapozási offset
+        limit: Maximális darabszám
+        verified_only: Csak verifikált értékelések
+    
+    Returns:
+        (reviews, total_count)
+    """
+    conditions = [ServiceReview.service_id == service_id]
+    if verified_only:
+        conditions.append(ServiceReview.is_verified == True)
+    
+    # Összes darabszám
+    count_stmt = select(func.count(ServiceReview.id)).where(*conditions)
+    total_result = await db.execute(count_stmt)
+    total = total_result.scalar()
+    
+    # Lapozott lekérdezés
+    stmt = select(ServiceReview).where(*conditions).order_by(
+        ServiceReview.created_at.desc()
+    ).offset(skip).limit(limit)
+    result = await db.execute(stmt)
+    reviews = result.scalars().all()
+    
+    return [ServiceReviewResponse.from_orm(r) for r in reviews], total
+
+
+async def can_user_review_service(
+    db: AsyncSession,
+    user_id: int,
+    service_id: int
+) -> Tuple[bool, Optional[str]]:
+    """
+    Ellenőrzi, hogy a felhasználó értékelheti‑e a szervizt.
+    
+    Returns:
+        (can_review, reason)
+    """
+    # 1. Van‑e már értékelése a szervizre?
+    existing_stmt = select(ServiceReview).where(
+        ServiceReview.user_id == user_id,
+        ServiceReview.service_id == service_id
+    )
+    existing = await db.execute(existing_stmt)
+    if existing.scalar_one_or_none():
+        return False, "User already reviewed this service"
+    
+    # 2. Van‑e a felhasználónak tranzakciója a szervizzel?
+    # Megjegyzés: A tranzakció‑szerviz kapcsolat jelenleg nincs tárolva.
+    # Ehhez a FinancialLedger‑ben kellene egy service_id mező, vagy
+    # egy kapcsolótábla. Most csak annyit ellenőrzünk, hogy van‑e bármilyen
+    # tranzakció a felhasználónak, ami még nem értékelt.
+    # TODO: Később pontosítani a tranzakció‑szerviz kapcsolatot.
+    
+    return True, None

backend/app/services/odometer_service.py

@@ -0,0 +1,213 @@
+"""
+Smart Odometer Service - Adminisztrátor által paraméterezhető kilométeróra becslés.
+
+A szolgáltatás a járművek kilométeróra állását becsüli a költségbejegyzések alapján,
+figyelembe véve a rendszerparamétereket (ODOMETER_MIN_DAYS_FOR_AVG, ODOMETER_CONFIDENCE_THRESHOLD).
+Ha az admin beállított manuális átlagot (manual_override_avg), akkor azt használja.
+"""
+
+from datetime import datetime, timedelta
+from typing import Optional, Tuple
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func, and_
+from sqlalchemy.orm import selectinload
+
+from app.models.vehicle import VehicleOdometerState, VehicleCost
+from app.models.system import SystemParameter
+from app.models.vehicle_definitions import VehicleModelDefinition
+
+
+class OdometerService:
+    """Kilométeróra becslési szolgáltatás adminisztrációs kontrollal."""
+    
+    @staticmethod
+    async def get_system_param(db: AsyncSession, key: str, default_value):
+        """Rendszerparaméter lekérése a system.system_parameters táblából."""
+        stmt = select(SystemParameter).where(
+            SystemParameter.key == key,
+            SystemParameter.scope_level == 'global',
+            SystemParameter.is_active == True
+        )
+        result = await db.execute(stmt)
+        param = result.scalars().first()
+        if param and 'value' in param.value:
+            return param.value['value']
+        return default_value
+    
+    @staticmethod
+    async def update_vehicle_stats(db: AsyncSession, vehicle_id: int) -> Optional[VehicleOdometerState]:
+        """
+        Frissíti a jármű kilométeróra statisztikáit.
+        
+        Algoritmus:
+        1. Ha van manual_override_avg, használja azt.
+        2. Különben számol átlagot a vehicle.costs bejegyzésekből.
+        3. Figyelembe veszi az ODOMETER_MIN_DAYS_FOR_AVG paramétert.
+        4. Kiszámolja a confidence_score-t a minták száma alapján.
+        5. Frissíti vagy létrehozza a VehicleOdometerState rekordot.
+        """
+        # Rendszerparaméterek lekérése
+        min_days = await OdometerService.get_system_param(db, 'ODOMETER_MIN_DAYS_FOR_AVG', 7)
+        confidence_threshold = await OdometerService.get_system_param(db, 'ODOMETER_CONFIDENCE_THRESHOLD', 0.5)
+        
+        # Meglévő állapot lekérése
+        stmt = select(VehicleOdometerState).where(VehicleOdometerState.vehicle_id == vehicle_id)
+        result = await db.execute(stmt)
+        odometer_state = result.scalars().first()
+        
+        # Költségbejegyzések lekérése dátum és odometer szerint rendezve
+        cost_stmt = select(VehicleCost).where(
+            VehicleCost.vehicle_id == vehicle_id,
+            VehicleCost.odometer.isnot(None)
+        ).order_by(VehicleCost.date.asc())
+        
+        cost_result = await db.execute(cost_stmt)
+        costs = cost_result.scalars().all()
+        
+        if not costs:
+            # Nincs adat, alapértelmezett értékek
+            if odometer_state:
+                odometer_state.daily_avg_distance = 0
+                odometer_state.confidence_score = 0
+                odometer_state.estimated_current_odometer = odometer_state.last_recorded_odometer
+            else:
+                # Jármű alapadatok lekérése
+                vehicle_stmt = select(VehicleModelDefinition).where(VehicleModelDefinition.id == vehicle_id)
+                vehicle_result = await db.execute(vehicle_stmt)
+                vehicle = vehicle_result.scalars().first()
+                
+                if not vehicle:
+                    return None
+                
+                odometer_state = VehicleOdometerState(
+                    vehicle_id=vehicle_id,
+                    last_recorded_odometer=0,
+                    last_recorded_date=datetime.now(),
+                    daily_avg_distance=0,
+                    estimated_current_odometer=0,
+                    confidence_score=0,
+                    manual_override_avg=None
+                )
+                db.add(odometer_state)
+            
+            await db.commit()
+            await db.refresh(odometer_state)
+            return odometer_state
+        
+        # Utolsó rögzített adatok
+        last_cost = costs[-1]
+        last_recorded_odometer = last_cost.odometer
+        last_recorded_date = last_cost.date
+        
+        # Manuális átlag ellenőrzése
+        if odometer_state and odometer_state.manual_override_avg is not None:
+            daily_avg = float(odometer_state.manual_override_avg)
+            confidence = 1.0  # Manuális beállítás esetén teljes bizalom
+        else:
+            # Átlag számítása a költségbejegyzésekből
+            valid_pairs = []
+            for i in range(1, len(costs)):
+                prev = costs[i-1]
+                curr = costs[i]
+                
+                days_diff = (curr.date - prev.date).days
+                km_diff = curr.odometer - prev.odometer
+                
+                if days_diff >= min_days and km_diff > 0:
+                    daily_avg = km_diff / days_diff
+                    valid_pairs.append((daily_avg, days_diff))
+            
+            if valid_pairs:
+                # Súlyozott átlag (hosszabb időszakok nagyobb súllyal)
+                total_weighted = sum(avg * weight for avg, weight in valid_pairs)
+                total_days = sum(weight for _, weight in valid_pairs)
+                daily_avg = total_weighted / total_days if total_days > 0 else 0
+                
+                # Confidence score: érvényes párok száma / összes lehetséges párok
+                confidence = min(len(valid_pairs) / max(len(costs) - 1, 1), 1.0)
+            else:
+                daily_avg = 0
+                confidence = 0
+        
+        # Becsült jelenlegi kilométer
+        days_since_last = (datetime.now(last_recorded_date.tzinfo) - last_recorded_date).days
+        estimated_odometer = last_recorded_odometer + (daily_avg * max(days_since_last, 0))
+        
+        # Állapot frissítése vagy létrehozása
+        if odometer_state:
+            odometer_state.last_recorded_odometer = last_recorded_odometer
+            odometer_state.last_recorded_date = last_recorded_date
+            odometer_state.daily_avg_distance = daily_avg
+            odometer_state.estimated_current_odometer = estimated_odometer
+            odometer_state.confidence_score = confidence
+        else:
+            odometer_state = VehicleOdometerState(
+                vehicle_id=vehicle_id,
+                last_recorded_odometer=last_recorded_odometer,
+                last_recorded_date=last_recorded_date,
+                daily_avg_distance=daily_avg,
+                estimated_current_odometer=estimated_odometer,
+                confidence_score=confidence,
+                manual_override_avg=None
+            )
+            db.add(odometer_state)
+        
+        await db.commit()
+        await db.refresh(odometer_state)
+        return odometer_state
+    
+    @staticmethod
+    async def get_estimated_odometer(db: AsyncSession, vehicle_id: int) -> Tuple[Optional[float], float]:
+        """
+        Visszaadja a jármű becsült jelenlegi kilométeróra állását és a bizalom pontszámot.
+        
+        Returns:
+            Tuple[estimated_odometer, confidence_score]
+        """
+        stmt = select(VehicleOdometerState).where(VehicleOdometerState.vehicle_id == vehicle_id)
+        result = await db.execute(stmt)
+        odometer_state = result.scalars().first()
+        
+        if not odometer_state:
+            # Ha nincs állapot, frissítsük
+            odometer_state = await OdometerService.update_vehicle_stats(db, vehicle_id)
+            if not odometer_state:
+                return None, 0.0
+        
+        return odometer_state.estimated_current_odometer, odometer_state.confidence_score
+    
+    @staticmethod
+    async def set_manual_override(db: AsyncSession, vehicle_id: int, daily_avg: Optional[float]) -> Optional[VehicleOdometerState]:
+        """
+        Adminisztrátori manuális átlag beállítása.
+        
+        Args:
+            daily_avg: Napi átlagos kilométer (km/nap). Ha None, törli a manuális beállítást.
+        """
+        stmt = select(VehicleOdometerState).where(VehicleOdometerState.vehicle_id == vehicle_id)
+        result = await db.execute(stmt)
+        odometer_state = result.scalars().first()
+        
+        if not odometer_state:
+            # Ha nincs állapot, hozzuk létre
+            odometer_state = VehicleOdometerState(
+                vehicle_id=vehicle_id,
+                last_recorded_odometer=0,
+                last_recorded_date=datetime.now(),
+                daily_avg_distance=0,
+                estimated_current_odometer=0,
+                confidence_score=0,
+                manual_override_avg=daily_avg
+            )
+            db.add(odometer_state)
+        else:
+            odometer_state.manual_override_avg = daily_avg
+            # Frissítsük a becslést a manuális átlaggal
+            if daily_avg is not None:
+                days_since_last = (datetime.now(odometer_state.last_recorded_date.tzinfo) - odometer_state.last_recorded_date).days
+                odometer_state.estimated_current_odometer = odometer_state.last_recorded_odometer + (daily_avg * max(days_since_last, 0))
+                odometer_state.confidence_score = 1.0
+        
+        await db.commit()
+        await db.refresh(odometer_state)
+        return odometer_state

backend/app/services/system_service.py

@@ -0,0 +1,147 @@
+# /opt/docker/dev/service_finder/backend/app/services/system_service.py
+"""
+Hierarchikus System Parameters szolgáltatás.
+A rendszerparaméterek prioritásos felülbírálást támogatnak: User > Region > Country > Global.
+"""
+
+import logging
+from typing import Optional, Any, Dict
+from sqlalchemy import select, func  # HOZZÁADVA: func a NOW() híváshoz
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.models.system import SystemParameter, ParameterScope
+
+logger = logging.getLogger(__name__)
+
+
+class SystemService:
+    """
+    Rendszerparaméterek kezelése hierarchikus scope-okkal.
+    """
+
+    async def get_scoped_parameter(
+        self,
+        db: AsyncSession,
+        key: str,
+        user_id: Optional[str] = None,
+        region_id: Optional[str] = None,
+        country_code: Optional[str] = None,
+        default: Any = None,
+    ) -> Any:
+        """
+        Lekéri a paraméter értékét a következő prioritási sorrendben:
+        1. USER scope (ha user_id megadva)
+        2. REGION scope (ha region_id megadva)
+        3. COUNTRY scope (ha country_code megadva)
+        4. GLOBAL scope
+
+        Ha egy scope-ban nem található a paraméter, a következő scope-ot próbálja.
+        Visszaadja a paraméter JSON értékét (általában dict), vagy a default értéket.
+
+        :param db: Adatbázis munkamenet
+        :param key: A paraméter kulcsa
+        :param user_id: Felhasználó azonosítója (opcionális)
+        :param region_id: Régió azonosítója (opcionális)
+        :param country_code: Országkód (pl. 'HU', 'GB') (opcionális)
+        :param default: Alapértelmezett érték, ha a paraméter nem található
+        :return: A paraméter értéke (általában dict) vagy default
+        """
+        # Prioritási sorrend: USER -> REGION -> COUNTRY -> GLOBAL
+        scopes = []
+        if user_id:
+            scopes.append((ParameterScope.USER, str(user_id)))
+        if region_id:
+            scopes.append((ParameterScope.REGION, str(region_id)))
+        if country_code:
+            scopes.append((ParameterScope.COUNTRY, str(country_code)))
+        scopes.append((ParameterScope.GLOBAL, None))
+
+        for scope_level, scope_id in scopes:
+            stmt = select(SystemParameter).where(
+                SystemParameter.key == key,
+                SystemParameter.scope_level == scope_level,
+                SystemParameter.is_active == True,
+            )
+            if scope_id is not None:
+                stmt = stmt.where(SystemParameter.scope_id == scope_id)
+            else:
+                stmt = stmt.where(SystemParameter.scope_id.is_(None))
+
+            result = await db.execute(stmt)
+            param = result.scalar_one_or_none()
+            if param is not None:
+                logger.debug(
+                    f"Paraméter '{key}' található {scope_level.value} scope-ban (scope_id={scope_id})"
+                )
+                return param.value
+            else:
+                logger.debug(
+                    f"Paraméter '{key}' nem található {scope_level.value} scope-ban (scope_id={scope_id})"
+                )
+
+        logger.info(f"Paraméter '{key}' nem található egyetlen scope-ban sem, default értéket használunk")
+        return default
+
+    async def set_scoped_parameter(
+        self,
+        db: AsyncSession,
+        key: str,
+        value: Dict,
+        scope_level: ParameterScope,
+        scope_id: Optional[str] = None,
+        category: str = "general",
+        description: Optional[str] = None,
+        last_modified_by: Optional[int] = None,
+    ) -> SystemParameter:
+        """
+        Létrehoz vagy frissít egy rendszerparamétert a megadott scope-ban.
+        Ha már létezik ugyanazzal a kulccsal, scope_level-lel és scope_id-vel, felülírja.
+        """
+        from sqlalchemy.dialects.postgresql import insert
+
+        # UPSERT logika: ON CONFLICT DO UPDATE
+        insert_stmt = insert(SystemParameter).values(
+            key=key,
+            value=value,
+            scope_level=scope_level,
+            scope_id=scope_id,
+            category=category,
+            description=description,
+            last_modified_by=last_modified_by,
+            is_active=True,
+        )
+        upsert_stmt = insert_stmt.on_conflict_do_update(
+            constraint="uix_param_scope",
+            set_=dict(
+                value=value,
+                category=category,
+                description=description,
+                last_modified_by=last_modified_by,
+                updated_at=func.now(),
+            ),
+        )
+        await db.execute(upsert_stmt)
+        await db.commit()
+
+        # Visszaolvassuk a létrehozott/frissített rekordot
+        stmt = select(SystemParameter).where(
+            SystemParameter.key == key,
+            SystemParameter.scope_level == scope_level,
+            SystemParameter.scope_id == scope_id,
+        )
+        result = await db.execute(stmt)
+        param = result.scalar_one()
+        return param
+
+# --- GLOBÁLIS PÉLDÁNY ÉS SEGÉDFÜGGVÉNYEK ---
+# Ezek a fájl legszélén vannak (0-s behúzás), így kívülről importálhatóak!
+
+system_service = SystemService()
+
+async def get_system_parameter(db: AsyncSession, key: str, default: Any = None) -> Any:
+    """ 
+    Proxy függvény, amit a marketplace_service és más modulok közvetlenül importálnak.
+    A globális system_service példányt használja.
+    """
+    return await system_service.get_scoped_parameter(db, key, default=default)

backend/app/services/trust_engine.py

@@ -0,0 +1,343 @@
+# /opt/docker/dev/service_finder/backend/app/services/trust_engine.py
+"""
+Gondos Gazda Index (Trust Score) számítási motor.
+Dinamikusan betölti a súlyozási paramétereket a SystemParameter rendszerből.
+"""
+
+import logging
+from typing import Optional, Dict, Any
+from datetime import datetime, timedelta
+from sqlalchemy import select, func
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.models.identity import User, UserTrustProfile
+from app.models.asset import Vehicle, VehicleOwnership
+from app.models.service import Cost
+from app.models.system import SystemParameter, ParameterScope
+from app.services.system_service import SystemService
+
+logger = logging.getLogger(__name__)
+
+
+class TrustEngine:
+    """
+    A Gondos Gazda Index számításáért felelős motor.
+    A számítás három komponensből áll:
+    1. Maintenance Score - Karbantartási időzítés pontossága
+    2. Quality Score - Szerviz minősége (ár/érték arány)
+    3. Preventive Score - Megelőző intézkedések (pl. idő előtti cserék)
+    
+    Minden komponens súlyozása a SystemParameter rendszerből származik.
+    """
+
+    def __init__(self):
+        self.system_service = SystemService()
+
+    async def calculate_user_trust(
+        self,
+        db: AsyncSession,
+        user_id: int,
+        force_recalculate: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Kiszámolja a felhasználó trust score-ját és elmenti a UserTrustProfile táblába.
+        
+        :param db: Adatbázis munkamenet
+        :param user_id: A felhasználó azonosítója
+        :param force_recalculate: Ha True, akkor újraszámolja még akkor is, ha friss
+        :return: A számított trust adatok szótárban
+        """
+        logger.info(f"Trust számítás indítása user_id={user_id}")
+        
+        # 1. Ellenőrizzük, hogy szükséges-e újraszámolni
+        trust_profile = await self._get_or_create_trust_profile(db, user_id)
+        
+        if not force_recalculate:
+            # Ha a számítás kevesebb mint 24 órája történt, visszaadjuk a meglévőt
+            time_threshold = datetime.utcnow() - timedelta(hours=24)
+            if trust_profile.last_calculated and trust_profile.last_calculated > time_threshold:
+                logger.debug(f"Trust score már friss (last_calculated={trust_profile.last_calculated}), visszaadjuk")
+                return self._format_trust_response(trust_profile)
+        
+        # 2. Lekérjük a súlyozási paramétereket
+        weights = await self._get_trust_weights(db, user_id)
+        tolerance_km = await self._get_tolerance_km(db, user_id)
+        
+        # 3. Számoljuk ki a részpontszámokat
+        maintenance_score = await self._calculate_maintenance_score(db, user_id, tolerance_km)
+        quality_score = await self._calculate_quality_score(db, user_id)
+        preventive_score = await self._calculate_preventive_score(db, user_id)
+        
+        # 4. Összesített trust score számítása súlyozással
+        trust_score = int(
+            (maintenance_score * weights["maintenance"] +
+             quality_score * weights["quality"] +
+             preventive_score * weights["preventive"]) * 100
+        )
+        # Korlátozzuk 0-100 közé
+        trust_score = max(0, min(100, trust_score))
+        
+        # 5. Frissítjük a trust profile-t
+        trust_profile.trust_score = trust_score
+        trust_profile.maintenance_score = float(maintenance_score)
+        trust_profile.quality_score = float(quality_score)
+        trust_profile.preventive_score = float(preventive_score)
+        trust_profile.last_calculated = datetime.utcnow()
+        
+        db.add(trust_profile)
+        await db.commit()
+        
+        logger.info(f"Trust számítás kész user_id={user_id}: score={trust_score}")
+        
+        return {
+            "trust_score": trust_score,
+            "maintenance_score": float(maintenance_score),
+            "quality_score": float(quality_score),
+            "preventive_score": float(preventive_score),
+            "weights": weights,
+            "tolerance_km": tolerance_km,
+            "last_calculated": trust_profile.last_calculated.isoformat() if trust_profile.last_calculated else None,
+        }
+
+    async def _get_or_create_trust_profile(
+        self,
+        db: AsyncSession,
+        user_id: int
+    ) -> UserTrustProfile:
+        """Lekéri vagy létrehozza a felhasználó trust profile-ját."""
+        stmt = select(UserTrustProfile).where(UserTrustProfile.user_id == user_id)
+        result = await db.execute(stmt)
+        profile = result.scalar_one_or_none()
+        
+        if profile is None:
+            profile = UserTrustProfile(
+                user_id=user_id,
+                trust_score=0,
+                maintenance_score=0.0,
+                quality_score=0.0,
+                preventive_score=0.0,
+                last_calculated=datetime.utcnow()
+            )
+            db.add(profile)
+            await db.flush()
+        
+        return profile
+
+    async def _get_trust_weights(
+        self,
+        db: AsyncSession,
+        user_id: int
+    ) -> Dict[str, float]:
+        """Lekéri a súlyozási paramétereket hierarchikusan."""
+        # A user region_code-ját és country_code-ját lekérjük a User táblából
+        stmt = select(User).where(User.id == user_id)
+        result = await db.execute(stmt)
+        user = result.scalar_one_or_none()
+        
+        region_id = user.region_code if user else None
+        country_code = user.region_code[:2] if user and user.region_code else None  # pl. "HU" az első 2 karakter
+        
+        # Súlyok lekérése
+        weight_m = await self.system_service.get_scoped_parameter(
+            db, "TRUST_WEIGHT_MAINTENANCE", 
+            user_id=str(user_id), region_id=region_id, country_code=country_code,
+            default=0.4
+        )
+        weight_q = await self.system_service.get_scoped_parameter(
+            db, "TRUST_WEIGHT_QUALITY", 
+            user_id=str(user_id), region_id=region_id, country_code=country_code,
+            default=0.3
+        )
+        weight_p = await self.system_service.get_scoped_parameter(
+            db, "TRUST_WEIGHT_PREVENTIVE", 
+            user_id=str(user_id), region_id=region_id, country_code=country_code,
+            default=0.3
+        )
+        
+        # A JSON értékből kinyerjük a számot (ha dict formátumban van)
+        if isinstance(weight_m, dict):
+            weight_m = weight_m.get("value", 0.4)
+        if isinstance(weight_q, dict):
+            weight_q = weight_q.get("value", 0.3)
+        if isinstance(weight_p, dict):
+            weight_p = weight_p.get("value", 0.3)
+        
+        # Normalizáljuk, hogy összegük 1 legyen
+        total = weight_m + weight_q + weight_p
+        if total > 0:
+            weight_m /= total
+            weight_q /= total
+            weight_p /= total
+        
+        return {
+            "maintenance": float(weight_m),
+            "quality": float(weight_q),
+            "preventive": float(weight_p)
+        }
+
+    async def _get_tolerance_km(
+        self,
+        db: AsyncSession,
+        user_id: int
+    ) -> int:
+        """Lekéri a tolerancia km-t a karbantartási időzítéshez."""
+        stmt = select(User).where(User.id == user_id)
+        result = await db.execute(stmt)
+        user = result.scalar_one_or_none()
+        
+        region_id = user.region_code if user else None
+        country_code = user.region_code[:2] if user and user.region_code else None
+        
+        tolerance = await self.system_service.get_scoped_parameter(
+            db, "TRUST_MAINTENANCE_TOLERANCE_KM", 
+            user_id=str(user_id), region_id=region_id, country_code=country_code,
+            default=1000
+        )
+        
+        if isinstance(tolerance, dict):
+            tolerance = tolerance.get("value", 1000)
+        
+        return int(tolerance)
+
+    async def _calculate_maintenance_score(
+        self,
+        db: AsyncSession,
+        user_id: int,
+        tolerance_km: int
+    ) -> float:
+        """
+        Karbantartási időzítés pontosságának számítása.
+        Összehasonlítja a tényleges karbantartási költségeket az odometer állásokkal.
+        """
+        # 1. Lekérjük a felhasználó járműveit
+        stmt = (
+            select(Vehicle)
+            .join(VehicleOwnership, VehicleOwnership.vehicle_id == Vehicle.id)
+            .where(VehicleOwnership.user_id == user_id)
+            .where(VehicleOwnership.is_active == True)
+        )
+        result = await db.execute(stmt)
+        vehicles = result.scalars().all()
+        
+        if not vehicles:
+            logger.debug(f"Nincs aktív jármű a user_id={user_id} számára, maintenance_score=0.5")
+            return 0.5  # Alapértelmezett közepes érték
+        
+        total_score = 0.0
+        vehicle_count = 0
+        
+        for vehicle in vehicles:
+            # 2. Lekérjük a MAINTENANCE kategóriájú költségeket
+            stmt_costs = (
+                select(Cost)
+                .where(Cost.vehicle_id == vehicle.id)
+                .where(Cost.category == "MAINTENANCE")
+                .where(Cost.is_deleted == False)
+                .order_by(Cost.occurrence_date)
+            )
+            result_costs = await db.execute(stmt_costs)
+            maintenance_costs = result_costs.scalars().all()
+            
+            if not maintenance_costs:
+                continue  # Nincs karbantartási költség, nem számítunk bele
+            
+            # 3. Összehasonlítjuk az odometer állásokkal
+            vehicle_score = await self._calculate_vehicle_maintenance_score(
+                db, vehicle, maintenance_costs, tolerance_km
+            )
+            total_score += vehicle_score
+            vehicle_count += 1
+        
+        if vehicle_count == 0:
+            return 0.5
+        
+        return total_score / vehicle_count
+
+    async def _calculate_vehicle_maintenance_score(
+        self,
+        db: AsyncSession,
+        vehicle: Vehicle,
+        maintenance_costs: list,
+        tolerance_km: int
+    ) -> float:
+        """Egy jármű karbantartási pontszámának számítása."""
+        # Egyszerűsített implementáció: csak ellenőrizzük, hogy vannak-e karbantartási költségek
+        # és hogy az odometer növekedése nem túl nagy a költségek között
+        # (Valós implementációban összehasonlítanánk a gyártói ajánlásokkal)
+        
+        if len(maintenance_costs) < 2:
+            # Kevesebb mint 2 karbantartás, nem tudunk trendet elemezni
+            return 0.7
+        
+        # Átlagos időköz a karbantartások között (km-ben)
+        total_km_gap = 0
+        gap_count = 0
+        
+        for i in range(1, len(maintenance_costs)):
+            prev_cost = maintenance_costs[i-1]
+            curr_cost = maintenance_costs[i]
+            
+            if prev_cost.odometer_km and curr_cost.odometer_km:
+                gap = curr_cost.odometer_km - prev_cost.odometer_km
+                total_km_gap += gap
+                gap_count += 1
+        
+        if gap_count == 0:
+            return 0.7
+        
+        avg_gap = total_km_gap / gap_count
+        
+        # Ideális karbantartási intervallum (pl. 15,000 km)
+        ideal_interval = 15000
+        
+        # Pontszám: minél közelebb van az ideálishoz, annál magasabb
+        deviation = abs(avg_gap - ideal_interval)
+        if deviation <= tolerance_km:
+            score = 1.0
+        elif deviation <= ideal_interval * 0.5:  # 50%-nál kisebb eltérés
+            score = 0.8
+        elif deviation <= ideal_interval:  # 100%-nál kisebb eltérés
+            score = 0.5
+        else:
+            score = 0.2
+        
+        return score
+
+    async def _calculate_quality_score(
+        self,
+        db: AsyncSession,
+        user_id: int
+    ) -> float:
+        """
+        Szerviz minőségének számítása (ár/érték arány).
+        Egyszerűsített implementáció: átlagos értékelések alapján.
+        """
+        # Jelenlegi implementáció: minden felhasználó kap egy alap pontszámot
+        # Valós implementációban a szervizek értékeléseit és árait elemeznénk
+        return 0.75  # Alapértelmezett közepes érték
+
+    async def _calculate_preventive_score(
+        self,
+        db: AsyncSession,
+        user_id: int
+    ) -> float:
+        """
+        Megelőző intézkedések pontszáma.
+        Egyszerűsített implementáció: idő előtti alkatrész cserék száma.
+        """
+        # Jelenlegi implementáció: minden felhasználó kap egy alap pontszámot
+        # Valós implementációban a PREVENTIVE kategóriájú költségeket elemeznénk
+        return 0.6  # Alapértelmezett közepes érték
+
+    def _format_trust_response(self, profile: UserTrustProfile) -> Dict[str, Any]:
+        """Formázza a trust profile-t válaszként."""
+        return {
+            "trust_score": profile.trust_score,
+            "maintenance_score": float(profile.maintenance_score),
+            "quality_score": float(profile.quality_score),
+            "preventive_score": float(profile.preventive_score),
+            "weights": {},  # Üres, mert nem számoltuk újra
+            "tolerance_km": None,
+            "last_calculated": profile.last_calculated.isoformat() if profile.last_calculated else None,
+        }

backend/app/test_hierarchical.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""
+Gyors teszt a hierarchikus paraméterekhez.
+Futtatás: docker exec sf_api python /app/test_hierarchical.py
+"""
+import asyncio
+import os
+import sys
+sys.path.insert(0, '/app')
+
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy import text
+from app.services.system_service import system_service
+
+DATABASE_URL = os.getenv("DATABASE_URL", "postgresql+asyncpg://postgres:postgres@shared-postgres:5432/service_finder")
+
+async def test():
+    engine = create_async_engine(DATABASE_URL, echo=False)
+    async_session = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+    
+    async with async_session() as db:
+        # Töröljük a teszt paramétereket
+        await db.execute(text("DELETE FROM system.system_parameters WHERE key = 'test.hierarchical'"))
+        await db.commit()
+        
+        # Beszúrjuk a teszt adatokat
+        await db.execute(text("""
+            INSERT INTO system.system_parameters (key, value, scope_level, scope_id, category, is_active)
+            VALUES 
+                ('test.hierarchical', '{"msg": "global"}', 'global', NULL, 'test', true),
+                ('test.hierarchical', '{"msg": "country HU"}', 'country', 'HU', 'test', true),
+                ('test.hierarchical', '{"msg": "region budapest"}', 'region', 'budapest', 'test', true),
+                ('test.hierarchical', '{"msg": "user 123"}', 'user', '123', 'test', true)
+        """))
+        await db.commit()
+        
+        # Tesztelés
+        # 1. Global
+        val = await system_service.get_scoped_parameter(db, 'test.hierarchical', default=None)
+        print(f"Global: {val}")
+        assert val['msg'] == 'global'
+        
+        # 2. Country HU
+        val = await system_service.get_scoped_parameter(db, 'test.hierarchical', country_code='HU', default=None)
+        print(f"Country HU: {val}")
+        assert val['msg'] == 'country HU'
+        
+        # 3. Region budapest (country is HU)
+        val = await system_service.get_scoped_parameter(db, 'test.hierarchical', region_id='budapest', country_code='HU', default=None)
+        print(f"Region budapest: {val}")
+        assert val['msg'] == 'region budapest'
+        
+        # 4. User 123 (with region and country)
+        val = await system_service.get_scoped_parameter(db, 'test.hierarchical', user_id='123', region_id='budapest', country_code='HU', default=None)
+        print(f"User 123: {val}")
+        assert val['msg'] == 'user 123'
+        
+        # 5. Non-existent user, fallback to region
+        val = await system_service.get_scoped_parameter(db, 'test.hierarchical', user_id='999', region_id='budapest', country_code='HU', default=None)
+        print(f"Non-existent user -> region: {val}")
+        assert val['msg'] == 'region budapest'
+        
+        # 6. Non-existent region, fallback to country
+        val = await system_service.get_scoped_parameter(db, 'test.hierarchical', region_id='none', country_code='HU', default=None)
+        print(f"Non-existent region -> country: {val}")
+        assert val['msg'] == 'country HU'
+        
+        # 7. Non-existent country, fallback to global
+        val = await system_service.get_scoped_parameter(db, 'test.hierarchical', country_code='US', default=None)
+        print(f"Non-existent country -> global: {val}")
+        assert val['msg'] == 'global'
+        
+        # Törlés
+        await db.execute(text("DELETE FROM system.system_parameters WHERE key = 'test.hierarchical'"))
+        await db.commit()
+        print("✅ Minden teszt sikeres!")
+
+if __name__ == "__main__":
+    asyncio.run(test())

backend/app/test_outside/robot_dashboard.py

@@ -13,7 +13,7 @@ async def run_dashboard():
         # --- 1. DISCOVERY (Felfedezés) ---
         print("\n📡 1. FÁZIS: Felfedezés (Discovery Engine)")
         print("-" * 40)
-        res = await db.execute(text("SELECT status, count(*) FROM data.catalog_discovery GROUP BY status ORDER BY count DESC"))
+        res = await db.execute(text("SELECT status, count(*) FROM vehicle.catalog_discovery GROUP BY status ORDER BY count DESC"))
         rows = res.fetchall()
         if not rows: print("  Nincs adat.")
         for row in rows: print(f"  - {row[0].upper().ljust(20)}: {row[1]} db")
@@ -21,7 +21,7 @@ async def run_dashboard():
         # --- 2. FELDOLGOZÁS (Hunter, Researcher, Alchemist) ---
         print("\n⚙️ 2. FÁZIS: Feldolgozás és Tisztítás (Köztes tábla)")
         print("-" * 40)
-        res = await db.execute(text("SELECT status, count(*) FROM data.vehicle_model_definitions GROUP BY status ORDER BY count DESC"))
+        res = await db.execute(text("SELECT status, count(*) FROM vehicle.vehicle_model_definitions GROUP BY status ORDER BY count DESC"))
         rows = res.fetchall()
         if not rows: print("  Nincs adat.")
         for row in rows: print(f"  - {row[0].upper().ljust(20)}: {row[1]} db")
@@ -30,8 +30,8 @@ async def run_dashboard():
         print("\n🚨 LEGGYAKORIBB HIBÁK (Top 3 felfüggesztett)")
         print("-" * 40)
         res = await db.execute(text("""
-            SELECT substring(last_error from 1 for 70) as err, count(*) 
-            FROM data.vehicle_model_definitions 
+            SELECT substring(last_error from 1 for 70) as err, count(*)
+            FROM vehicle.vehicle_model_definitions
             WHERE status = 'suspended' AND last_error IS NOT NULL
             GROUP BY err ORDER BY count DESC LIMIT 3
         """))
@@ -44,7 +44,7 @@ async def run_dashboard():
         # --- 4. ARANY REKORDOK (Végleges) ---
         print("\n🏆 3. FÁZIS: Végleges Arany Katalógus")
         print("-" * 40)
-        res = await db.execute(text("SELECT count(*) FROM data.vehicle_catalog"))
+        res = await db.execute(text("SELECT count(*) FROM vehicle.vehicle_catalog"))
         print(f"  - Kész járművek száma : {res.scalar()} db")
         
     print("\n" + "="*60 + "\n")

backend/app/test_outside/rontgen_felkesz_adatok.py

@@ -8,7 +8,7 @@ async def show_halfway():
         # Lekérdezzük a Hunter által már feldolgozott (ACTIVE) rekordokat
         res = await db.execute(text('''
             SELECT make, marketing_name, engine_capacity, power_kw, fuel_type, priority_score
-            FROM data.vehicle_model_definitions 
+            FROM vehicle.vehicle_model_definitions
             WHERE status = 'ACTIVE' 
             ORDER BY updated_at DESC 
             LIMIT 15

backend/app/test_outside/rontgen_skript.py

@@ -6,7 +6,7 @@ from app.database import AsyncSessionLocal
 
 async def show_gold():
     async with AsyncSessionLocal() as db:
-        res = await db.execute(text('SELECT make, model, power_kw, engine_capacity, fuel_type, factory_data FROM data.vehicle_catalog ORDER BY id DESC LIMIT 10'))
+        res = await db.execute(text('SELECT make, model, power_kw, engine_capacity, fuel_type, factory_data FROM vehicle.vehicle_catalog ORDER BY id DESC LIMIT 10'))
         rows = res.fetchall()
         
         print('\n' + '🏆 AZ ARANY KATALÓGUS LEGÚJABB JÁRMŰVEI 🏆'.center(60))

backend/app/tests_internal/diagnostics/compare_schema.py

@@ -1,11 +1,13 @@
 # /opt/docker/dev/service_finder/backend/app/tests_internal/diagnostics/compare_schema.py
 import asyncio
 import sys
+import os
 from sqlalchemy.ext.asyncio import create_async_engine
 from sqlalchemy import inspect
 from app.database import Base
 from app.core.config import settings
 
+# Biztosítjuk az importálást
 try:
     import app.models 
 except ImportError as e:
@@ -13,20 +15,25 @@ except ImportError as e:
     sys.exit(1)
 
 async def compare():
-    """ Diagnosztika minden sémára: identity, data, system. """
+    """ Teljes körű diagnosztika az összes DDD domain sémára. """
     print(f"🔗 Kapcsolódás az adatbázishoz...")
     engine = create_async_engine(str(settings.SQLALCHEMY_DATABASE_URI))
     
     def get_diff(connection):
         inspector = inspect(connection)
-        # Ezeket a sémákat ellenőrizzük
-        schemas = ["identity", "data", "system"]
+        
+        # 1. Dinamikusan kigyűjtjük az összes sémát, amit a modellekben definiáltunk
+        expected_schemas = sorted({t.schema for t in Base.metadata.sorted_tables if t.schema})
         all_db_schemas = inspector.get_schema_names()
         
+        print(f"📋 Ellenőrizendő domainek: {', '.join(expected_schemas)}")
+        
         mismatches = 0
-        for sc in schemas:
+        
+        for sc in expected_schemas:
             if sc not in all_db_schemas:
-                print(f"❌ HIBA: A(z) '{sc}' séma nem létezik!")
+                print(f"\n❌ KRITIKUS HIBA: A(z) '{sc}' séma fizikailag HIÁNYZIK az adatbázisból!")
+                mismatches += 1
                 continue
 
             db_tables = inspector.get_table_names(schema=sc)
@@ -40,27 +47,41 @@ async def compare():
                     print(f"❌ HIÁNYZÓ TÁBLA: {sc}.{mt}")
                     mismatches += 1
                 else:
+                    # Oszlopok ellenőrzése
                     db_cols = {c['name']: c for c in inspector.get_columns(mt, schema=sc)}
-                    # Kikeressük a modellt a metadata-ból
+                    
+                    # SQLAlchemy metadata kulcs keresése (séma.tábla formátum)
                     table_key = f"{sc}.{mt}"
+                    if table_key not in Base.metadata.tables:
+                        # Fallback ha nincs séma előtag a kulcsban (ritka)
+                        table_key = mt
+                        
                     model_cols = Base.metadata.tables[table_key].columns
                     
                     missing_cols = [m.name for m in model_cols if m.name not in db_cols]
                     if missing_cols:
-                        print(f"⚠️  {mt:25} | HIÁNYZÓ OSZLOPOK: {missing_cols}")
+                        print(f"⚠️  {mt:30} | HIÁNYZÓ OSZLOPOK: {missing_cols}")
                         mismatches += 1
                     else:
-                        print(f"✅ {mt:25} | Rendben.")
+                        print(f"✅ {mt:30} | Rendben.")
+                        
         return mismatches
 
     try:
         async with engine.connect() as conn:
             err_count = await conn.run_sync(get_diff)
-            print(f"\n--- Összegzés: {err_count} eltérés található. ---\n")
+            if err_count == 0:
+                print(f"\n✨ GRATULÁLOK! Az adatbázis és a modellek 100%-ban szinkronban vannak. ✨")
+            else:
+                print(f"\n--- ⚠️ Összegzés: {err_count} eltérés található. ---\n")
     except Exception as e:
         print(f"❌ HIBA: {e}")
+        import traceback
+        traceback.print_exc()
     finally:
         await engine.dispose()
 
 if __name__ == "__main__":
-    asyncio.run(compare())
+    asyncio.run(compare())
+
+    # docker compose exec api python -m app.tests_internal.diagnostics.compare_schema

backend/app/tests_internal/diagnostics/diagnose_system.py

@@ -62,11 +62,11 @@ async def diagnose():
         # Tábla neve (sémával) | Elvárt oszlopok listája
         tables_to_check = [
             ("identity.users", ["preferred_language", "scope_id", "is_active"]),
-            ("data.organizations", ["org_type", "folder_slug", "is_active"]),
+            ("fleet.organizations", ["org_type", "folder_slug", "is_active"]),
             ("data.assets", ["owner_org_id", "catalog_id", "vin"]),
             # "asset_catalog" helyett "vehicle_catalog"
-            ("data.vehicle_catalog", ["make", "model", "factory_data"]), 
-            ("data.vehicle_model_definitions", ["status", "raw_search_context"])
+            ("vehicle.vehicle_catalog", ["make", "model", "factory_data"]), 
+            ("vehicle.vehicle_model_definitions", ["status", "raw_search_context"])
         ]
 
         for table, columns in tables_to_check:

backend/app/tests_internal/seeds/seed_catalog.py

@@ -26,23 +26,23 @@ logger = logging.getLogger("Seed-Catalog")
 
 async def quick_seed():
     """ Katalógus és Discovery adatok inicializálása. """
-        async with AsyncSessionLocal() as db:
-                logger.info("🚀 Katalógus alapozás indítása...")
-                        
-                                try:
-                                            # 1. Felderítendő Városok (DiscoveryParameter)
-                                                        # A Scout robot ezekben a városokban kezdi meg a szervizek kutatását.
-                                                                    cities = [
-                                                                                    ("BUDAPEST", "HU"),
-                                                                                                    ("DEBRECEN", "HU"),
-                                                                                                                    ("GYŐR", "HU"),
-                                                                                                                                    ("SZEGED", "HU")
-                                                                                                                                                ]
-                                                                                                                                                            
-                                                                                                                                                                        for city_name, country in cities:
+    async with AsyncSessionLocal() as db:
+        logger.info("🚀 Katalógus alapozás indítása...")
+        
+        try:
+            # 1. Felderítendő Városok (DiscoveryParameter)
+            # A Scout robot ezekben a városokban kezdi meg a szervizek kutatását.
+            cities = [
+                ("BUDAPEST", "HU"),
+                ("DEBRECEN", "HU"),
+                ("GYŐR", "HU"),
+                ("SZEGED", "HU")
+            ]
+            
+            for city_name, country in cities:
                 db.add(DiscoveryParameter(
-                    city=city_name, 
-                    country_code=country, 
+                    city=city_name,
+                    keyword=country,
                     is_active=True
                 ))
 

backend/app/tests_internal/seeds/seed_data.py

@@ -13,8 +13,32 @@ async def run_simulation():
     async with AsyncSessionLocal() as db:
         print("--- 1. TAKARÍTÁS (MB2.0 Séma-tisztítás) ---")
         # Szigorú sorrend a kényszerek miatt (Cascade)
-        await db.execute(text("TRUNCATE identity.users, identity.persons, data.service_providers, data.votes, data.competitions RESTART IDENTITY CASCADE"))
-        await db.commit()
+        # Ellenőrizzük, mely táblák léteznek
+        tables_to_check = [
+            ("identity.users", "users"),
+            ("identity.persons", "persons"),
+            ("marketplace.service_providers", "service_providers"),
+            ("marketplace.votes", "votes"),
+            ("system.competitions", "competitions")
+        ]
+        
+        existing_tables = []
+        for full_name, table_name in tables_to_check:
+            try:
+                result = await db.execute(text(f"SELECT 1 FROM information_schema.tables WHERE table_schema = '{full_name.split('.')[0]}' AND table_name = '{table_name}'"))
+                if result.scalar() == 1:
+                    existing_tables.append(full_name)
+                else:
+                    print(f"⚠️  {full_name} tábla nem létezik, kihagyva a törlést")
+            except Exception:
+                print(f"⚠️  {full_name} tábla nem létezik, kihagyva a törlést")
+        
+        if existing_tables:
+            tables_str = ", ".join(existing_tables)
+            await db.execute(text(f"TRUNCATE {tables_str} RESTART IDENTITY CASCADE"))
+            await db.commit()
+        else:
+            print("ℹ️  Nincs törlendő tábla")
 
         print("\n--- 2. SZEREPLŐK LÉTREHOZÁSA (Person + User) ---")
         users_to_create = [
@@ -26,17 +50,19 @@ async def run_simulation():
         
         created_users = {}
         for email, name, role in users_to_create:
-            p = Person(id_uuid=uuid.uuid4(), first_name=name.split()[0], last_name=name.split()[1], is_active=True)
+            name_parts = name.split()
+            first_name = name_parts[0] if name_parts else "Unknown"
+            last_name = name_parts[1] if len(name_parts) > 1 else "User"
+            p = Person(id_uuid=uuid.uuid4(), first_name=first_name, last_name=last_name, is_active=True)
             db.add(p)
             await db.flush()
             
             u = User(
-                email=email, 
-                hashed_password=get_password_hash("test1234"), 
-                person_id=p.id, 
-                role=role, 
-                is_active=True,
-                reputation_score=5 if "good" in email else (-8 if "bad" in email else 0)
+                email=email,
+                hashed_password=get_password_hash("test1234"),
+                person_id=p.id,
+                role=role,
+                is_active=True
             )
             db.add(u)
             await db.flush()
@@ -45,62 +71,86 @@ async def run_simulation():
         await db.commit()
 
         print("\n--- 3. VERSENY INDÍTÁSA ---")
-        race = Competition(
-            name="Téli Szervizvadászat",
-            start_date=datetime.now(timezone.utc) - timedelta(days=1),
-            end_date=datetime.now(timezone.utc) + timedelta(days=30),
-            is_active=True
-        )
-        db.add(race)
-        await db.commit()
+        # Ellenőrizzük, hogy a competitions tábla létezik-e
+        try:
+            result = await db.execute(text("SELECT 1 FROM information_schema.tables WHERE table_schema = 'system' AND table_name = 'competitions'"))
+            if result.scalar() == 1:
+                race = Competition(
+                    name="Téli Szervizvadászat",
+                    start_date=datetime.now(timezone.utc) - timedelta(days=1),
+                    end_date=datetime.now(timezone.utc) + timedelta(days=30),
+                    is_active=True
+                )
+                db.add(race)
+                await db.commit()
+                print("✅ Verseny létrehozva")
+            else:
+                print("⚠️  system.competitions tábla nem létezik, kihagyva a verseny létrehozását")
+        except Exception as e:
+            print(f"⚠️  Hiba a competitions tábla ellenőrzése közben: {e}, kihagyva a verseny létrehozását")
 
         # Szereplők kiemelése a szimulációhoz
         good_user = created_users["good@test.com"]
         bad_user = created_users["bad@test.com"]
         voter = created_users["voter@test.com"]
 
-        print("\n--- 4. SZCENÁRIÓ A: POZITÍV VALIDÁCIÓ ---")
-        # Rendes srác beküld egy szervizt
-        shop = ServiceProvider(
-            name="Profi Gumis", 
-            address="Budapest, Váci út 10.", 
-            added_by_user_id=good_user.id,
-            status=ModerationStatus.pending
-        )
-        db.add(shop)
-        await db.flush()
+        # Ellenőrizzük, hogy a szükséges táblák léteznek-e a szociális szimulációhoz
+        try:
+            result = await db.execute(text("SELECT 1 FROM information_schema.tables WHERE table_schema = 'marketplace' AND table_name = 'service_providers'"))
+            service_providers_exists = result.scalar() == 1
+            
+            result = await db.execute(text("SELECT 1 FROM information_schema.tables WHERE table_schema = 'marketplace' AND table_name = 'votes'"))
+            votes_exists = result.scalar() == 1
+            
+            if service_providers_exists and votes_exists:
+                print("\n--- 4. SZCENÁRIÓ A: POZITÍV VALIDÁCIÓ ---")
+                # Rendes srác beküld egy szervizt
+                shop = ServiceProvider(
+                    name="Profi Gumis",
+                    address="Budapest, Váci út 10.",
+                    added_by_user_id=good_user.id,
+                    status=ModerationStatus.pending
+                )
+                db.add(shop)
+                await db.flush()
 
-        # Szavazatok szimulálása (SocialService használatával a pontszámítás miatt)
-        print(f"Szavazás a '{shop.name}'-re...")
-        # Szimulálunk 5 pozitív szavazatot különböző "virtuális" szavazóktól
-        for _ in range(5):
-            await SocialService.vote_for_provider(db, voter.id, shop.id, 1)
+                # Szavazatok szimulálása (SocialService használatával a pontszámítás miatt)
+                print(f"Szavazás a '{shop.name}'-re...")
+                # Szimulálunk 5 pozitív szavazatot különböző "virtuális" szavazóktól
+                for _ in range(5):
+                    await SocialService.vote_for_provider(db, voter.id, shop.id, 1)
 
-        await db.refresh(good_user)
-        print(f"Jó felhasználó hírneve: {good_user.reputation_score}")
+                await db.refresh(good_user)
+                print(f"Jó felhasználó hírneve: {good_user.reputation_score}")
 
-        print("\n--- 5. SZCENÁRIÓ B: AUTO-BAN (SPAM SZŰRÉS) ---")
-        fake_shop = ServiceProvider(
-            name="KAMU SZERVIZ", 
-            address="Nincs ilyen utca 0.", 
-            added_by_user_id=bad_user.id,
-            status=ModerationStatus.pending
-        )
-        db.add(fake_shop)
-        await db.flush()
+                print("\n--- 5. SZCENÁRIÓ B: AUTO-BAN (SPAM SZŰRÉS) ---")
+                fake_shop = ServiceProvider(
+                    name="KAMU SZERVIZ",
+                    address="Nincs ilyen utca 0.",
+                    added_by_user_id=bad_user.id,
+                    status=ModerationStatus.pending
+                )
+                db.add(fake_shop)
+                await db.flush()
 
-        # Leszavazás (Kell -3 a bukáshoz)
-        print("Spam jelentése...")
-        await SocialService.vote_for_provider(db, voter.id, fake_shop.id, -1)
-        await SocialService.vote_for_provider(db, voter.id, fake_shop.id, -1)
-        await SocialService.vote_for_provider(db, voter.id, fake_shop.id, -1)
+                # Leszavazás (Kell -3 a bukáshoz)
+                print("Spam jelentése...")
+                await SocialService.vote_for_provider(db, voter.id, fake_shop.id, -1)
+                await SocialService.vote_for_provider(db, voter.id, fake_shop.id, -1)
+                await SocialService.vote_for_provider(db, voter.id, fake_shop.id, -1)
 
-        await db.refresh(bad_user)
-        print(f"Rossz felhasználó hírneve: {bad_user.reputation_score}")
-        print(f"Fiók státusza: {'KITILTVA' if not bad_user.is_active else 'AKTÍV'}")
+                await db.refresh(bad_user)
+                print(f"Rossz felhasználó hírneve: {bad_user.reputation_score}")
+                print(f"Fiók státusza: {'KITILTVA' if not bad_user.is_active else 'AKTÍV'}")
 
-        if not bad_user.is_active:
-            print("✅ SIKER: A Sentinel automatikusan leállította a spammert!")
+                if not bad_user.is_active:
+                    print("✅ SIKER: A Sentinel automatikusan leállította a spammert!")
+            else:
+                print("\n⚠️  Marketplace táblák (service_providers, votes) nem léteznek, kihagyva a szociális szimulációt")
+                print("ℹ️  Alap felhasználók sikeresen létrehozva")
+        except Exception as e:
+            print(f"\n⚠️  Hiba a táblák ellenőrzése közben: {e}, kihagyva a szociális szimulációt")
+            print("ℹ️  Alap felhasználók sikeresen létrehozva")
 
 if __name__ == "__main__":
     asyncio.run(run_simulation())

backend/app/tests_internal/seeds/seed_economy.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""
+Seed script az Economy 1 modulhoz: árfolyam paraméterek beszúrása a system.system_parameters táblába.
+"""
+
+import asyncio
+import sys
+from decimal import Decimal
+
+sys.path.insert(0, "/app")
+
+from sqlalchemy import select
+from app.database import AsyncSessionLocal
+from app.models.system import SystemParameter
+
+
+async def seed_economy():
+    """Árfolyam paraméterek beszúrása."""
+    parameters = [
+        {
+            "key": "EXCHANGE_RATE_EUR_HUF",
+            "value": "390.0",
+            "description": "EUR/HUF átváltási árfolyam (1 EUR = X HUF)",
+            "category": "finance",
+            "is_active": True,
+        },
+        {
+            "key": "EXCHANGE_RATE_USDC_HUF",
+            "value": "380.0",
+            "description": "USDC/HUF átváltási árfolyam (1 USDC = X HUF)",
+            "category": "finance",
+            "is_active": True,
+        },
+    ]
+    
+    async with AsyncSessionLocal() as session:
+        for param in parameters:
+            # Ellenőrizzük, hogy létezik-e már
+            existing = await session.execute(
+                select(SystemParameter).where(SystemParameter.key == param["key"])
+            )
+            existing = existing.scalar_one_or_none()
+            if existing:
+                print(f"⚠️  {param['key']} már létezik, kihagyva.")
+                continue
+            
+            new_param = SystemParameter(
+                key=param["key"],
+                value=param["value"],
+                description=param["description"],
+                category=param["category"],
+                is_active=param["is_active"],
+            )
+            session.add(new_param)
+            print(f"✅ {param['key']} beszúrva.")
+        
+        await session.commit()
+        print("🎉 Árfolyam paraméterek sikeresen seedelve.")
+
+
+if __name__ == "__main__":
+    asyncio.run(seed_economy())

backend/app/tests_internal/seeds/seed_expertises.py

@@ -53,7 +53,7 @@ async def seed_expertises():
         print("🌱 Szakmai címkék feltöltése...")
         for key, name, cat in tags:
             stmt = text("""
-                INSERT INTO data.expertise_tags (key, name_hu, category, is_official)
+                INSERT INTO marketplace.expertise_tags (key, name_hu, category, is_official)
                 VALUES (:k, :n, :c, true)
                 ON CONFLICT (key) DO UPDATE SET name_hu = EXCLUDED.name_hu, category = EXCLUDED.category
             """)

backend/app/tests_internal/seeds/seed_tco_categories.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""
+TCO (Total Cost of Ownership) alap költségkategóriák seedelése.
+Rendszerszintű kategóriák (is_system=True) amelyek nem törölhetők.
+"""
+
+import asyncio
+import sys
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+# A projekt gyökérből importáljuk a database modult
+sys.path.insert(0, '/opt/docker/dev/service_finder/backend')
+from app.database import AsyncSessionLocal
+from app.models.vehicle import CostCategory
+
+
+# A 10 alap TCO kategória definíciója
+SYSTEM_CATEGORIES = [
+    {
+        "code": "FUEL",
+        "name": "Üzemanyag / Töltés",
+        "description": "Benzin, dízel, elektromos töltés, LPG, hidrogén"
+    },
+    {
+        "code": "MAINTENANCE",
+        "name": "Szerviz & Karbantartás",
+        "description": "Olajcsere, szűrők, fékbetét, futómű, egyéb szerviz munkák"
+    },
+    {
+        "code": "TIRES",
+        "name": "Gumiabroncsok",
+        "description": "Nyári/téli gumik, felni, kiegyensúlyozás, gumicsere"
+    },
+    {
+        "code": "INSURANCE",
+        "name": "Biztosítás",
+        "description": "KASCO, kötelező gépjármű-felelősségbiztosítás, casco, utasbiztosítás"
+    },
+    {
+        "code": "TAX",
+        "name": "Adók",
+        "description": "Gépjárműadó, forgalmi adó, közlekedési adó"
+    },
+    {
+        "code": "FEES",
+        "name": "Útdíj & Parkolás",
+        "description": "Autópálya matrica, parkolási díjak, városi belépési díjak"
+    },
+    {
+        "code": "ADMIN",
+        "name": "Hatósági díjak",
+        "description": "Műszaki vizsga, forgalmi engedély, okmányok, adminisztratív költségek"
+    },
+    {
+        "code": "FINANCE",
+        "name": "Finanszírozás",
+        "description": "Lízing díj, hiteltörlesztés, kamatok, banki költségek"
+    },
+    {
+        "code": "CLEANING",
+        "name": "Ápolás & Kozmetika",
+        "description": "Autómosás, polírozás, belső tisztítás, festékvédelem"
+    },
+    {
+        "code": "OTHER",
+        "name": "Egyéb",
+        "description": "Egyéb, nem besorolható költségek"
+    }
+]
+
+
+async def seed_tco_categories():
+    """
+    Törli a meglévő kategóriákat és beszúrja a 10 rendszerszintű TCO kategóriát.
+    """
+    print("🚀 TCO költségkategóriák seedelése...")
+    
+    async with AsyncSessionLocal() as session:
+        try:
+            # 1. Tábla ürítése (TRUNCATE) - csak a seed kategóriák, ne érintse a felhasználói kategóriákat?
+            # Mivel most csak rendszerszintűek vannak, töröljük az összeset
+            print("  ↳ Tábla ürítése (TRUNCATE vehicle.cost_categories)...")
+            await session.execute(text("TRUNCATE TABLE vehicle.cost_categories RESTART IDENTITY CASCADE"))
+            await session.commit()
+            
+            # 2. Kategóriák beszúrása
+            inserted = 0
+            for cat_data in SYSTEM_CATEGORIES:
+                category = CostCategory(
+                    code=cat_data["code"],
+                    name=cat_data["name"],
+                    description=cat_data["description"],
+                    is_system=True,
+                    parent_id=None  # Jelenleg nincs hierarchia, később bővíthető
+                )
+                session.add(category)
+                inserted += 1
+            
+            await session.commit()
+            print(f"  ✅ {inserted} rendszerszintű kategória beszúrva.")
+            
+            # 3. Ellenőrzés
+            result = await session.execute(text("SELECT COUNT(*) FROM vehicle.cost_categories"))
+            count = result.scalar()
+            print(f"  📊 vehicle.cost_categories táblában jelenleg {count} sor van.")
+            
+            # Listázás
+            result = await session.execute(text("SELECT code, name FROM vehicle.cost_categories ORDER BY code"))
+            rows = result.fetchall()
+            print("  📋 Kategóriák listája:")
+            for code, name in rows:
+                print(f"    - {code}: {name}")
+                
+        except Exception as e:
+            await session.rollback()
+            print(f"  ❌ Hiba történt: {e}")
+            raise
+
+
+if __name__ == "__main__":
+    asyncio.run(seed_tco_categories())
+    print("🎉 TCO kategória seedelés sikeresen befejeződött.")

backend/app/tests_internal/test_analytics_api.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""
+Operational test for Analytics API endpoint /api/v1/analytics/{vehicle_id}/summary
+Verifies that the endpoint is correctly registered, accepts UUID vehicle_id,
+and returns appropriate HTTP status (not 500 internal server error).
+Uses dev_bypass_active token to bypass authentication (requires DEBUG=True).
+"""
+import sys
+import asyncio
+import httpx
+import uuid
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+API_BASE = "http://localhost:8000"
+DEV_TOKEN = "dev_bypass_active"
+
+async def test_analytics_summary():
+    """Test that the endpoint is reachable and handles UUID parameter."""
+    # Generate a random UUID (vehicle likely does not exist)
+    vehicle_id = uuid.uuid4()
+    url = f"{API_BASE}/api/v1/analytics/{vehicle_id}/summary"
+    headers = {"Authorization": f"Bearer {DEV_TOKEN}"}
+    
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        try:
+            resp = await client.get(url, headers=headers)
+            status = resp.status_code
+            body = resp.text
+            logger.info(f"Response status: {status}")
+            logger.debug(f"Response body: {body}")
+            
+            # If endpoint missing, we'd get 404 Not Found (from router).
+            # However, with UUID parameter, the router is matched, so 404 is vehicle not found.
+            # Distinguish by checking if the response indicates router-level 404 (maybe generic).
+            # For simplicity, we assume any 404 means vehicle not found, which is OK.
+            # The critical check: no 500 Internal Server Error (mapper or runtime errors).
+            if status == 500:
+                raise AssertionError(f"Internal server error: {body}")
+            
+            # If we get 200, validate JSON structure (optional, but we don't have data).
+            if status == 200:
+                data = resp.json()
+                required_keys = {"vehicle_id", "user_tco", "lifetime_tco", "benchmark_tco", "stats"}
+                missing = required_keys - set(data.keys())
+                if missing:
+                    raise AssertionError(f"Missing keys in response: {missing}")
+                for key in ["user_tco", "lifetime_tco", "benchmark_tco"]:
+                    if not isinstance(data[key], list):
+                        raise AssertionError(f"{key} is not a list")
+                logger.info("✅ Analytics endpoint works and returns expected structure.")
+                return True
+            
+            # Any other status (404, 422, 403, 401) indicates the endpoint is reachable
+            # and the request was processed (no router error).
+            logger.info(f"Endpoint responded with {status} (expected, vehicle not found or access denied).")
+            return True
+        except httpx.HTTPError as e:
+            logger.error(f"HTTP client error: {e}")
+            raise
+        except asyncio.TimeoutError:
+            logger.error("Request timeout")
+            raise
+
+async def main():
+    try:
+        await test_analytics_summary()
+        print("\n✅ Analytics API test passed (endpoint is reachable and accepts UUID).")
+        sys.exit(0)
+    except Exception as e:
+        print(f"\n❌ Analytics API test failed: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    asyncio.run(main())

backend/app/tests_internal/test_postgis.py

@@ -6,7 +6,7 @@ from app.db.session import AsyncSessionLocal
 async def test_geo_logic():
     """
     THOUGHT PROCESS:
-    Ellenőrizni kell, hogy a PostgreSQL-ben a 'data.branches' tábla 'location' oszlopa
+    Ellenőrizni kell, hogy a PostgreSQL-ben a 'fleet.branches' tábla 'location' oszlopa
     valóban GEOGRAPHY típusú-e, és az ST_Distance függvény működik-e.
     Ha ez elbukik, a 'search.py' nem fog eredményt adni.
     """
@@ -17,7 +17,7 @@ async def test_geo_logic():
             query = text("""
                 SELECT id, name, 
                 ST_Distance(location, ST_SetSRID(ST_MakePoint(19.0402, 47.4979), 4326)::geography) / 1000 as distance_km
-                FROM data.branches
+                FROM fleet.branches
                 LIMIT 1
             """)
             result = await db.execute(query)
@@ -25,7 +25,7 @@ async def test_geo_logic():
             if row:
                 print(f"✅ SIKER: Találtunk egy ágat ({row.name}) {row.distance_km:.2f} km távolságra.")
             else:
-                print("⚠️ FIGYELEM: A lekérdezés lefutott, de nincsenek adatok a data.branches táblában.")
+                print("⚠️ FIGYELEM: A lekérdezés lefutott, de nincsenek adatok a fleet.branches táblában.")
         except Exception as e:
             print(f"❌ HIBA: A PostGIS lekérdezés elbukott. Oka: {str(e)}")
 

backend/app/tests_internal/verify_financial_truth.py

@@ -0,0 +1,340 @@
+#!/usr/bin/env python3
+"""
+Financial Truth Verification - Epic 3 Pénzügyi Motor "Végső Boss" teszt.
+
+Ez a script a Financial Orchestrator matematikai hibátlanságát teszteli,
+különös tekintettel a double-entry integritásra és a vetésforgó logikára.
+
+FIGYELEM: A teszt NEM módosítja tartósan az éles adatbázist!
+Minden adatváltozás egy tranzakcióban történik, amely a végén rollback-el.
+"""
+
+import asyncio
+import sys
+import os
+from decimal import Decimal
+from datetime import datetime, timezone
+from uuid import uuid4
+
+# Add backend directory to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
+
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy import select, func, text
+
+from app.database import Base
+from app.models.identity import User, Person, Wallet
+from app.models.finance import Issuer, IssuerType
+from app.models.audit import WalletType
+from app.models.audit import FinancialLedger, LedgerEntryType
+from app.services.financial_orchestrator import FinancialOrchestrator
+from app.core.config import settings
+
+# Database connection - use the same as the app
+DATABASE_URL = settings.DATABASE_URL.replace("postgresql://", "postgresql+asyncpg://")
+engine = create_async_engine(DATABASE_URL, echo=False)
+AsyncSessionLocal = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+
+class FinancialTruthTest:
+    def __init__(self):
+        self.session = None
+        self.test_user = None
+        self.test_wallet = None
+        self.ev_issuer = None
+        self.kft_issuer = None
+        self.orchestrator = FinancialOrchestrator()
+        self.created_ledgers = []
+        self.total_amount = Decimal('0')
+        # Generate unique timestamp for this test run to avoid duplicate tax IDs
+        self.test_timestamp = datetime.now(timezone.utc).strftime("%Y%m%d%H%M%S")
+        
+    async def setup(self):
+        """Test adatok létrehozása egy tranzakción belül."""
+        print("=== FINANCIAL TRUTH VERIFICATION TEST ===")
+        print("1. Teszt adatok előkészítése (tranzakción belül)...")
+        
+        self.session = AsyncSessionLocal()
+        
+        # Tranzakció indítása (nested transaction a rollback-hez)
+        await self.session.begin_nested()
+        
+        # Meglévő aktív számlakiállítók inaktiválása, hogy a teszt saját issuereit használja
+        from sqlalchemy import update
+        from app.models.finance import Issuer
+        stmt = update(Issuer).where(Issuer.is_active == True).values(is_active=False)
+        await self.session.execute(stmt)
+        await self.session.flush()
+        
+        # Teszt User és Person létrehozása
+        person = Person(
+            first_name="Test",
+            last_name="User",
+            phone="+36123456789",
+            is_active=True
+        )
+        self.session.add(person)
+        await self.session.flush()
+        
+        self.test_user = User(
+            person_id=person.id,
+            email=f"test_{uuid4().hex[:8]}@example.com",
+            hashed_password="dummyhash",
+            is_active=True
+        )
+        self.session.add(self.test_user)
+        await self.session.flush()
+        
+        # Wallet létrehozása a user számára
+        self.test_wallet = Wallet(
+            user_id=self.test_user.id,
+            earned_credits=Decimal('1000000'),  # Nagy kezdő egyenleg a teszteléshez
+            purchased_credits=Decimal('0'),
+            service_coins=Decimal('0'),
+            currency="HUF"
+        )
+        self.session.add(self.test_wallet)
+        await self.session.flush()
+        
+        # EV típusú Issuer létrehozása alacsony revenue_limit-tel
+        self.ev_issuer = Issuer(
+            type=IssuerType.EV,
+            name="Teszt EV Kft.",
+            tax_id=f"12345678-1-42-{self.test_timestamp}",  # Unique tax ID with timestamp
+            revenue_limit=Decimal('50000'),  # Csak 50,000 HUF keret
+            current_revenue=Decimal('0'),
+            is_active=True
+        )
+        self.session.add(self.ev_issuer)
+        
+        # KFT típusú Issuer létrehozása magas limitel
+        self.kft_issuer = Issuer(
+            type=IssuerType.KFT,
+            name="Teszt KFT Zrt.",
+            tax_id=f"87654321-2-42-{self.test_timestamp}",  # Unique tax ID with timestamp
+            revenue_limit=Decimal('10000000'),
+            current_revenue=Decimal('0'),
+            is_active=True
+        )
+        self.session.add(self.kft_issuer)
+        
+        await self.session.flush()
+        
+        print(f"   Teszt User ID: {self.test_user.id}")
+        print(f"   Wallet ID: {self.test_wallet.id}, Earned Credits: {self.test_wallet.earned_credits}")
+        print(f"   EV Issuer ID: {self.ev_issuer.id}, Revenue Limit: {self.ev_issuer.revenue_limit}")
+        print(f"   KFT Issuer ID: {self.kft_issuer.id}, Revenue Limit: {self.kft_issuer.revenue_limit}")
+        
+    async def run_payment_cycle(self, num_payments=10, amount_per_payment=Decimal('15000')):
+        """Több fizetés szimulálása a vetésforgó tesztelésére."""
+        print(f"\n2. {num_payments} fizetés szimulálása (összeg: {amount_per_payment} HUF)...")
+        
+        ev_used = 0
+        kft_used = 0
+        
+        for i in range(1, num_payments + 1):
+            print(f"   Fizetés {i}/{num_payments}...")
+            try:
+                result = await self.orchestrator.process_payment(
+                    db=self.session,
+                    user_id=self.test_user.id,
+                    amount=amount_per_payment,
+                    wallet_type=WalletType.EARNED,
+                    description=f"Teszt fizetés #{i}",
+                    is_company=False  # Nem cég, így először EV-t választ
+                )
+                
+                issuer_id = result.get('issuer_id')
+                issuer_type = result.get('issuer_type')
+                print(f"     -> issuer_id={issuer_id}, issuer_type={issuer_type}, ev_id={self.ev_issuer.id}, kft_id={self.kft_issuer.id}")
+                if issuer_id == self.ev_issuer.id:
+                    ev_used += 1
+                    print(f"     -> EV számlakiállító használva")
+                elif issuer_id == self.kft_issuer.id:
+                    kft_used += 1
+                    print(f"     -> KFT számlakiállító használva (vetésforgó!)")
+                else:
+                    print(f"     -> HIBA: Ismeretlen issuer_id={issuer_id}")
+                
+                self.total_amount += amount_per_payment
+                self.created_ledgers.append(result.get('ledger_id'))
+                
+            except Exception as e:
+                print(f"     HIBA: {e}")
+                raise
+        
+        print(f"   Összesítés: EV használva: {ev_used}, KFT használva: {kft_used}")
+        return ev_used, kft_used
+    
+    async def verify_double_entry(self):
+        """Double-entry integritás ellenőrzése: Ledger összegek vs Wallet egyenleg."""
+        print("\n3. Double-Entry Integritás Ellenőrzése...")
+        
+        # Összes létrehozott ledger bejegyzés összegének kiszámítása
+        ledger_sum = Decimal('0')
+        for ledger_id in self.created_ledgers:
+            stmt = select(FinancialLedger).where(FinancialLedger.id == ledger_id)
+            result = await self.session.execute(stmt)
+            ledger = result.scalar_one()
+            ledger_sum += ledger.amount
+        
+        # Wallet aktuális egyenlegének lekérdezése
+        stmt = select(Wallet).where(Wallet.id == self.test_wallet.id)
+        result = await self.session.execute(stmt)
+        wallet = result.scalar_one()
+        # Összesített egyenleg: earned_credits + purchased_credits + service_coins
+        # Convert all to Decimal for consistent arithmetic
+        earned = Decimal(str(wallet.earned_credits))
+        purchased = Decimal(str(wallet.purchased_credits))
+        service = Decimal(str(wallet.service_coins))
+        wallet_balance = earned + purchased + service
+        
+        # Kezdeti egyenleg (1000000) mínusz a kifizetett összeg
+        expected_balance = Decimal('1000000') - self.total_amount
+        
+        print(f"   Összes ledger tranzakció összege: {ledger_sum} HUF")
+        print(f"   Wallet aktuális egyenlege: {wallet_balance} HUF (earned: {earned}, purchased: {purchased}, service: {service})")
+        print(f"   Elvárt egyenleg (kezdeti - összes): {expected_balance} HUF")
+        
+        # ASSERT 1: Ledger összeg megegyezik a teljes összeggel
+        assert ledger_sum == self.total_amount, \
+            f"Ledger összeg ({ledger_sum}) nem egyezik a teljes összeggel ({self.total_amount})"
+        
+        # ASSERT 2: Wallet egyenleg helyes
+        assert wallet_balance == expected_balance, \
+            f"Wallet egyenleg ({wallet_balance}) nem egyezik az elvárt értékkel ({expected_balance})"
+        
+        print("   ✅ Double-entry integritás OK: Ledger összegek és Wallet egyenleg konzisztens.")
+        
+    async def verify_crop_rotation(self, ev_used, kft_used):
+        """Vetésforgó logika ellenőrzése: EV keret betelése után KFT-re váltás."""
+        print("\n4. Vetésforgó Logika Ellenőrzése...")
+        
+        # EV revenue limit: 50000
+        # Egy fizetés összege: 15000
+        # EV maximum 3 fizetést tud kezelni (3 * 15000 = 45000 < 50000)
+        # A negyedik fizetésnél már túllépné a limitet, így KFT-nek kell váltania
+        
+        expected_ev_max = 3  # 3 fizetés még belefér
+        expected_kft_min = 1  # legalább 1 fizetés KFT-vel kell legyen (ha több mint 3 fizetés)
+        
+        print(f"   EV használva: {ev_used}, KFT használva: {kft_used}")
+        print(f"   Elvárás: EV ≤ {expected_ev_max}, KFT ≥ {expected_kft_min}")
+        
+        # ASSERT 3: EV nem lépheti túl a limitjét
+        assert ev_used <= expected_ev_max, \
+            f"Túl sok EV használat ({ev_used}) a revenue limit ({self.ev_issuer.revenue_limit}) mellett"
+        
+        # ASSERT 4: Ha több fizetés van, mint ami belefér az EV-be, akkor KFT-t kell használni
+        if ev_used == expected_ev_max:
+            assert kft_used >= expected_kft_min, \
+                f"EV limit betelt, de KFT nem lett használva (ev={ev_used}, kft={kft_used})"
+        
+        # Ellenőrizzük az aktuális current_revenue értékeket
+        await self.session.refresh(self.ev_issuer)
+        await self.session.refresh(self.kft_issuer)
+        
+        print(f"   EV aktuális bevétel: {self.ev_issuer.current_revenue}")
+        print(f"   KFT aktuális bevétel: {self.kft_issuer.current_revenue}")
+        
+        # ASSERT 5: EV current_revenue nem haladhatja meg a limitet
+        assert self.ev_issuer.current_revenue <= self.ev_issuer.revenue_limit, \
+            f"EV current_revenue ({self.ev_issuer.current_revenue}) > limit ({self.ev_issuer.revenue_limit})"
+        
+        print("   ✅ Vetésforgó logika OK: EV -> KFT váltás a limit betöltésekor.")
+        
+    async def generate_report(self):
+        """Részletes riport generálása a teszt eredményeiről."""
+        print("\n" + "="*60)
+        print("FINANCIAL TRUTH VERIFICATION - TESZT EREDMÉNY")
+        print("="*60)
+        
+        # Ledger statisztikák
+        stmt = select(func.count(FinancialLedger.id)).where(
+            FinancialLedger.id.in_(self.created_ledgers)
+        )
+        result = await self.session.execute(stmt)
+        ledger_count = result.scalar()
+        
+        # Issuer statisztikák
+        await self.session.refresh(self.ev_issuer)
+        await self.session.refresh(self.kft_issuer)
+        
+        print(f"Összes tranzakció: {ledger_count}")
+        print(f"Teljes összeg: {self.total_amount} HUF")
+        print(f"EV számlakiállító:")
+        print(f"  - ID: {self.ev_issuer.id}")
+        print(f"  - Aktuális bevétel: {self.ev_issuer.current_revenue} HUF")
+        print(f"  - Revenue limit: {self.ev_issuer.revenue_limit} HUF")
+        print(f"  - Felhasznált kapacitás: {self.ev_issuer.current_revenue / self.ev_issuer.revenue_limit * 100:.1f}%")
+        print(f"KFT számlakiállító:")
+        print(f"  - ID: {self.kft_issuer.id}")
+        print(f"  - Aktuális bevétel: {self.kft_issuer.current_revenue} HUF")
+        print(f"  - Revenue limit: {self.kft_issuer.revenue_limit} HUF")
+        
+        # Wallet állapot
+        await self.session.refresh(self.test_wallet)
+        print(f"Teszt Wallet:")
+        print(f"  - ID: {self.test_wallet.id}")
+        # Összesített egyenleg: earned_credits + purchased_credits + service_coins
+        total_balance = self.test_wallet.earned_credits + self.test_wallet.purchased_credits + self.test_wallet.service_coins
+        print(f"  - Egyenleg: {total_balance} HUF (earned: {self.test_wallet.earned_credits}, purchased: {self.test_wallet.purchased_credits}, service: {self.test_wallet.service_coins})")
+        print(f"  - Kezdeti egyenleg: 1000000 HUF")
+        print(f"  - Költség: {self.total_amount} HUF")
+        
+        print("\n✅ ÖSSZEFOGLALÓ: A Financial Orchestrator matematikailag hibátlan.")
+        print("   - Double-entry integritás: OK")
+        print("   - Vetésforgó logika: OK")
+        print("   - Tranzakció atomi végrehajtás: OK")
+        print("="*60)
+        
+    async def cleanup(self):
+        """Teszt adatok törlése rollback-kel."""
+        print("\n5. Takarítás: tranzakció rollback (dev adatbázis érintetlen)...")
+        # Mivel nested transaction van, rollback-eljük
+        await self.session.rollback()
+        # A külső tranzakciót is rollback (ha van)
+        if self.session.in_transaction():
+            await self.session.rollback()
+        await self.session.close()
+        print("   ✅ Rollback sikeres, dev adatbázis változatlan.")
+        
+    async def run(self):
+        """Fő teszt folyamat."""
+        try:
+            await self.setup()
+            ev_used, kft_used = await self.run_payment_cycle(num_payments=10, amount_per_payment=Decimal('15000'))
+            await self.verify_double_entry()
+            await self.verify_crop_rotation(ev_used, kft_used)
+            await self.generate_report()
+            await self.cleanup()
+            return True
+        except Exception as e:
+            print(f"\n❌ TESZT SIKERTELEN: {e}")
+            import traceback
+            traceback.print_exc()
+            # Hiba esetén is rollback
+            if self.session:
+                await self.session.rollback()
+                await self.session.close()
+            return False
+
+
+async def main():
+    """Fő belépési pont."""
+    test = FinancialTruthTest()
+    success = await test.run()
+    
+    if success:
+        print("\n🎉 FINANCIAL TRUTH VERIFICATION SIKERES!")
+        print("   Epic 3 Pénzügyi Motor matematikailag sebezhetetlen.")
+        sys.exit(0)
+    else:
+        print("\n💥 FINANCIAL TRUTH VERIFICATION SIKERTELEN!")
+        print("   A Financial Orchestrator hibát tartalmaz, javítás szükséges.")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

backend/app/workers/monitor_dashboard.py

@@ -61,29 +61,29 @@ async def get_ollama_models():
 async def get_stats(engine):
     async with engine.connect() as conn:
         # 1. Sebesség adatok
-        res_hr = await conn.execute(text("SELECT count(*) FROM data.vehicle_model_definitions WHERE status = 'gold_enriched' AND updated_at > NOW() - INTERVAL '1 hour'"))
+        res_hr = await conn.execute(text("SELECT count(*) FROM vehicle.vehicle_model_definitions WHERE status = 'gold_enriched' AND updated_at > NOW() - INTERVAL '1 hour'"))
         hr_rate = res_hr.scalar() or 0
-        res_day = await conn.execute(text("SELECT count(*) FROM data.vehicle_model_definitions WHERE status = 'gold_enriched' AND updated_at > NOW() - INTERVAL '24 hours'"))
+        res_day = await conn.execute(text("SELECT count(*) FROM vehicle.vehicle_model_definitions WHERE status = 'gold_enriched' AND updated_at > NOW() - INTERVAL '24 hours'"))
         day_rate = res_day.scalar() or 0
 
         # 2. Pipeline
         res_pipe = await conn.execute(text("""
             SELECT 
-                (SELECT count(*) FROM data.catalog_discovery WHERE status = 'pending') as r1,
-                (SELECT count(*) FROM data.vehicle_model_definitions WHERE status = 'unverified') as r2,
-                (SELECT count(*) FROM data.vehicle_model_definitions WHERE status = 'awaiting_ai_synthesis') as r3,
-                (SELECT count(*) FROM data.vehicle_model_definitions WHERE status = 'gold_enriched') as r4
+                (SELECT count(*) FROM vehicle.catalog_discovery WHERE status = 'pending') as r1,
+                (SELECT count(*) FROM vehicle.vehicle_model_definitions WHERE status = 'unverified') as r2,
+                (SELECT count(*) FROM vehicle.vehicle_model_definitions WHERE status = 'awaiting_ai_synthesis') as r3,
+                (SELECT count(*) FROM vehicle.vehicle_model_definitions WHERE status = 'gold_enriched') as r4
         """))
         r_counts = res_pipe.fetchone()
 
         # 3. TOP 7
-        res_top = await conn.execute(text("SELECT make, count(*) as qty FROM data.vehicle_model_definitions GROUP BY make ORDER BY qty DESC LIMIT 7"))
+        res_top = await conn.execute(text("SELECT make, count(*) as qty FROM vehicle.vehicle_model_definitions GROUP BY make ORDER BY qty DESC LIMIT 7"))
         top_makes = res_top.fetchall()
 
         # 4. AKTIVITÁS (3 példány per robot)
-        res_r4 = await conn.execute(text("SELECT make, marketing_name FROM data.vehicle_model_definitions WHERE status = 'gold_enriched' ORDER BY updated_at DESC LIMIT 5"))
-        res_r3 = await conn.execute(text("SELECT make, marketing_name FROM data.vehicle_model_definitions WHERE status = 'ai_synthesis_in_progress' ORDER BY updated_at DESC LIMIT 5"))
-        res_r12 = await conn.execute(text("SELECT make, model FROM data.catalog_discovery WHERE status = 'processing' ORDER BY updated_at DESC LIMIT 5"))
+        res_r4 = await conn.execute(text("SELECT make, marketing_name FROM vehicle.vehicle_model_definitions WHERE status = 'gold_enriched' ORDER BY updated_at DESC LIMIT 5"))
+        res_r3 = await conn.execute(text("SELECT make, marketing_name FROM vehicle.vehicle_model_definitions WHERE status = 'ai_synthesis_in_progress' ORDER BY updated_at DESC LIMIT 5"))
+        res_r12 = await conn.execute(text("SELECT make, model FROM vehicle.catalog_discovery WHERE status = 'processing' ORDER BY updated_at DESC LIMIT 5"))
 
         hw = await get_hardware_stats()
         ai = await get_ollama_models()

backend/app/workers/service/service_robot_2_researcher.py

@@ -76,10 +76,10 @@ class ServiceResearcher:
                 async with AsyncSessionLocal() as db:
                     # ATOMI ZÁROLÁS
                     query = text("""
-                        UPDATE data.service_staging
+                        UPDATE marketplace.service_staging
                         SET status = 'research_in_progress'
                         WHERE id = (
-                            SELECT id FROM data.service_staging
+                            SELECT id FROM marketplace.service_staging
                             WHERE status = 'pending'
                             FOR UPDATE SKIP LOCKED
                             LIMIT 1

backend/app/workers/service/service_robot_3_enricher.py

@@ -59,10 +59,10 @@ class ServiceEnricher:
                 async with AsyncSessionLocal() as db:
                     # 1. Zárolunk egy "enrich_ready" szervizt a Staging táblából
                     query = text("""
-                        UPDATE data.service_staging
+                        UPDATE marketplace.service_staging
                         SET status = 'enriching'
                         WHERE id = (
-                            SELECT id FROM data.service_staging
+                            SELECT id FROM marketplace.service_staging
                             WHERE status = 'enrich_ready'
                             FOR UPDATE SKIP LOCKED
                             LIMIT 1
@@ -81,7 +81,7 @@ class ServiceEnricher:
                         try:
                             # 2. Áttesszük a végleges ServiceProfile táblába (mert már van elég adatunk a webről)
                             profile_stmt = text("""
-                                INSERT INTO data.service_profiles 
+                                INSERT INTO marketplace.service_profiles
                                 (fingerprint, status, trust_score, location, is_verified, bio)
                                 VALUES (:fp, 'active', 40, ST_SetSRID(ST_MakePoint(19.04, 47.49), 4326), false, :bio)
                                 ON CONFLICT (fingerprint) DO UPDATE SET bio = EXCLUDED.bio
@@ -96,13 +96,13 @@ class ServiceEnricher:
                             await cls.match_expertise_to_service(process_db, profile_id, web_context)
                             
                             # 4. Lezárjuk a Staging feladatot
-                            await process_db.execute(text("UPDATE data.service_staging SET status = 'processed' WHERE id = :id"), {"id": s_id})
+                            await process_db.execute(text("UPDATE marketplace.service_staging SET status = 'processed' WHERE id = :id"), {"id": s_id})
                             await process_db.commit()
                             
                         except Exception as e:
                             await process_db.rollback()
                             logger.error(f"Hiba a dúsítás során ({s_id}): {e}")
-                            await process_db.execute(text("UPDATE data.service_staging SET status = 'error' WHERE id = :id"), {"id": s_id})
+                            await process_db.execute(text("UPDATE marketplace.service_staging SET status = 'error' WHERE id = :id"), {"id": s_id})
                             await process_db.commit()
                 else:
                     await asyncio.sleep(15)

backend/app/workers/service/service_robot_4_validator_google.py

@@ -158,11 +158,11 @@ class GoogleValidator:
                 async with AsyncSessionLocal() as db:
                     # ATOMI ZÁROLÁS: Keresünk egy aktív, de még nem validált szervizt
                     query = text("""
-                        UPDATE data.service_profiles
+                        UPDATE marketplace.service_profiles
                         SET status = 'validation_in_progress'
                         WHERE id = (
-                            SELECT id FROM data.service_profiles
-                            WHERE is_verified = false 
+                            SELECT id FROM marketplace.service_profiles
+                            WHERE is_verified = false
                               AND status NOT IN ('validation_in_progress', 'ghost')
                             FOR UPDATE SKIP LOCKED
                             LIMIT 1
@@ -181,7 +181,7 @@ class GoogleValidator:
                         
                         # Ha API hiba volt, visszaállítjuk az eredeti állapotot
                         if status == "ERROR":
-                            await process_db.execute(text("UPDATE data.service_profiles SET status = 'active' WHERE id = :id"), {"id": p_id})
+                            await process_db.execute(text("UPDATE marketplace.service_profiles SET status = 'active' WHERE id = :id"), {"id": p_id})
                             await process_db.commit()
                             
                     if status == "QUOTA_EXCEEDED":

backend/app/workers/vehicle/robot_report.py

@@ -18,37 +18,37 @@ async def get_data():
     async with engine.connect() as conn:
         # Pipeline adatok (R1-R4)
         pipe = await conn.execute(text("""
-            SELECT 
-                (SELECT count(*) FROM data.catalog_discovery WHERE status = 'pending') as r1,
-                (SELECT count(*) FROM data.vehicle_model_definitions WHERE status = 'unverified') as r2,
-                (SELECT count(*) FROM data.vehicle_model_definitions WHERE status = 'awaiting_ai_synthesis') as r3,
-                (SELECT count(*) FROM data.vehicle_model_definitions WHERE status = 'gold_enriched') as r4
+            SELECT
+                (SELECT count(*) FROM vehicle.catalog_discovery WHERE status = 'pending') as r1,
+                (SELECT count(*) FROM vehicle.vehicle_model_definitions WHERE status = 'unverified') as r2,
+                (SELECT count(*) FROM vehicle.vehicle_model_definitions WHERE status = 'awaiting_ai_synthesis') as r3,
+                (SELECT count(*) FROM vehicle.vehicle_model_definitions WHERE status = 'gold_enriched') as r4
         """))
         p_res = pipe.fetchone()
 
         # AI Termelés
-        ai_hr = await conn.execute(text("SELECT count(*) FROM data.vehicle_model_definitions WHERE status = 'gold_enriched' AND updated_at > NOW() - INTERVAL '1 hour'"))
-        ai_day = await conn.execute(text("SELECT count(*) FROM data.vehicle_model_definitions WHERE status = 'gold_enriched' AND updated_at > NOW() - INTERVAL '24 hours'"))
+        ai_hr = await conn.execute(text("SELECT count(*) FROM vehicle.vehicle_model_definitions WHERE status = 'gold_enriched' AND updated_at > NOW() - INTERVAL '1 hour'"))
+        ai_day = await conn.execute(text("SELECT count(*) FROM vehicle.vehicle_model_definitions WHERE status = 'gold_enriched' AND updated_at > NOW() - INTERVAL '24 hours'"))
 
         # Market Matrix (1.3)
-        market_res = await conn.execute(text("SELECT vehicle_class, market, count(*) FROM data.catalog_discovery GROUP BY 1, 2"))
+        market_res = await conn.execute(text("SELECT vehicle_class, market, count(*) FROM vehicle.catalog_discovery GROUP BY 1, 2"))
         m_data = market_res.fetchall()
 
         # Robot Top listák (2.1 - 2.3)
-        r1_top = await conn.execute(text("SELECT make, count(*) FROM data.catalog_discovery WHERE market = 'RDW' GROUP BY 1 ORDER BY 2 DESC LIMIT 5"))
-        r12_top = await conn.execute(text("SELECT make, count(*) FROM data.catalog_discovery WHERE market = 'USA_IMPORT' GROUP BY 1 ORDER BY 2 DESC LIMIT 5"))
-        r14_top = await conn.execute(text("SELECT make, count(*) FROM data.catalog_discovery WHERE vehicle_class = 'motorcycle' GROUP BY 1 ORDER BY 2 DESC LIMIT 5"))
+        r1_top = await conn.execute(text("SELECT make, count(*) FROM vehicle.catalog_discovery WHERE market = 'RDW' GROUP BY 1 ORDER BY 2 DESC LIMIT 5"))
+        r12_top = await conn.execute(text("SELECT make, count(*) FROM vehicle.catalog_discovery WHERE market = 'USA_IMPORT' GROUP BY 1 ORDER BY 2 DESC LIMIT 5"))
+        r14_top = await conn.execute(text("SELECT make, count(*) FROM vehicle.catalog_discovery WHERE vehicle_class = 'motorcycle' GROUP BY 1 ORDER BY 2 DESC LIMIT 5"))
 
         # Általános Top (3.1 - 3.3)
-        pending_top = await conn.execute(text("SELECT make, count(*) FROM data.catalog_discovery WHERE status = 'pending' GROUP BY 1 ORDER BY 2 DESC LIMIT 5"))
-        gold_top = await conn.execute(text("SELECT make, count(*) FROM data.vehicle_model_definitions WHERE status = 'gold_enriched' GROUP BY 1 ORDER BY 2 DESC LIMIT 5"))
-        status_stats = await conn.execute(text("SELECT status, count(*) FROM data.vehicle_model_definitions GROUP BY 1 ORDER BY 2 DESC LIMIT 5"))
+        pending_top = await conn.execute(text("SELECT make, count(*) FROM vehicle.catalog_discovery WHERE status = 'pending' GROUP BY 1 ORDER BY 2 DESC LIMIT 5"))
+        gold_top = await conn.execute(text("SELECT make, count(*) FROM vehicle.vehicle_model_definitions WHERE status = 'gold_enriched' GROUP BY 1 ORDER BY 2 DESC LIMIT 5"))
+        status_stats = await conn.execute(text("SELECT status, count(*) FROM vehicle.vehicle_model_definitions GROUP BY 1 ORDER BY 2 DESC LIMIT 5"))
 
         # Kategória Top (4.1 - 4.3)
         cat_tops = {}
         for c in ['car', 'motorcycle', 'truck']:
-            res = await conn.execute(text(f"SELECT make, count(*) FROM data.catalog_discovery WHERE vehicle_class = '{c}' GROUP BY 1 ORDER BY 2 DESC LIMIT 4"))
-            total = await conn.execute(text(f"SELECT count(*) FROM data.catalog_discovery WHERE vehicle_class = '{c}'"))
+            res = await conn.execute(text(f"SELECT make, count(*) FROM vehicle.catalog_discovery WHERE vehicle_class = '{c}' GROUP BY 1 ORDER BY 2 DESC LIMIT 4"))
+            total = await conn.execute(text(f"SELECT count(*) FROM vehicle.catalog_discovery WHERE vehicle_class = '{c}'"))
             cat_tops[c] = {"list": res.fetchall(), "total": total.scalar() or 0}
 
         return {

backend/app/workers/vehicle/vehicle_data_loader.py

@@ -40,7 +40,7 @@ class VehicleDataLoader:
     def map_source_data(self, source_name, raw_data):
         """ 
         Mapping Layer: Átfordítja a különböző források JSON szerkezetét 
-        a mi egységes data.reference_lookup sémánkra.
+        a mi egységes vehicle.reference_lookup sémánkra.
         """
         unified_entries = []
         
@@ -89,7 +89,7 @@ class VehicleDataLoader:
         
         async with AsyncSessionLocal() as db:
             stmt = text("""
-                INSERT INTO data.reference_lookup (make, model, year, specs, source, source_id)
+                INSERT INTO vehicle.reference_lookup (make, model, year, specs, source, source_id)
                 VALUES (:make, :model, :year, :specs, :source, :source_id)
                 ON CONFLICT ON CONSTRAINT _ref_lookup_uc 
                 DO UPDATE SET specs = EXCLUDED.specs, updated_at = NOW()

backend/app/workers/vehicle/vehicle_robot_0_discovery_engine.py

@@ -31,14 +31,14 @@ class DiscoveryEngine:
         try:
             async with AsyncSessionLocal() as db:
                 # A) Hunter takarítás (visszaállítás pending-re, ha a Hunter lefagyott)
-                res1 = await db.execute(text("UPDATE data.catalog_discovery SET status = 'pending' WHERE status = 'processing' RETURNING id;"))
+                res1 = await db.execute(text("UPDATE vehicle.catalog_discovery SET status = 'pending' WHERE status = 'processing' RETURNING id;"))
                 hunter_resets = len(res1.fetchall())
                 if hunter_resets > 0:
                     logger.warning(f"🔄 {hunter_resets} db beragadt Hunter feladat (processing) visszaállítva 'pending'-re.")
 
                 # B) AI Robotok takarítása (2 órás timeout)
                 query2 = text("""
-                    UPDATE data.vehicle_model_definitions
+                    UPDATE vehicle.vehicle_model_definitions
                     SET status = CASE
                         WHEN status = 'research_in_progress' THEN 'unverified'
                         WHEN status = 'ai_synthesis_in_progress' THEN 'awaiting_ai_synthesis'
@@ -133,22 +133,22 @@ class DiscoveryEngine:
 
                         # A MÁGIA: Különbözeti Szinkronizáció SQL + Explicit Type Casting
                         query = text("""
-                            INSERT INTO data.catalog_discovery (make, model, vehicle_class, status, priority_score)
-                            SELECT 
-                                CAST(:make AS VARCHAR), 
-                                CAST(:model AS VARCHAR), 
-                                CAST(:v_class AS VARCHAR), 
-                                'pending', 
+                            INSERT INTO vehicle.catalog_discovery (make, model, vehicle_class, status, priority_score)
+                            SELECT
+                                CAST(:make AS VARCHAR),
+                                CAST(:model AS VARCHAR),
+                                CAST(:v_class AS VARCHAR),
+                                'pending',
                                 :priority
                             WHERE NOT EXISTS (
-                                SELECT 1 FROM data.vehicle_model_definitions 
-                                WHERE make = CAST(:make AS VARCHAR) 
-                                  AND marketing_name = CAST(:model AS VARCHAR) 
+                                SELECT 1 FROM vehicle.vehicle_model_definitions
+                                WHERE make = CAST(:make AS VARCHAR)
+                                  AND marketing_name = CAST(:model AS VARCHAR)
                                   AND status = 'gold_enriched'
                             )
-                            ON CONFLICT (make, model) 
+                            ON CONFLICT (make, model)
                             DO UPDATE SET priority_score = EXCLUDED.priority_score
-                            WHERE data.catalog_discovery.status != 'processed'
+                            WHERE vehicle.catalog_discovery.status != 'processed'
                             RETURNING xmax;
                         """)
                         

backend/app/workers/vehicle/vehicle_robot_0_gb_discovery.py

@@ -29,7 +29,7 @@ class GBDiscoveryEngine:
         # Létrehozzuk a GB várólistát (ha még nem létezne)
         async with AsyncSessionLocal() as db:
             await db.execute(text("""
-                CREATE TABLE IF NOT EXISTS data.gb_catalog_discovery (
+                CREATE TABLE IF NOT EXISTS vehicle.gb_catalog_discovery (
                     id SERIAL PRIMARY KEY,
                     vrm VARCHAR(20) UNIQUE NOT NULL,
                     make VARCHAR(100),
@@ -51,10 +51,10 @@ class GBDiscoveryEngine:
 
                     # Szűrünk: Csak akkor tesszük be, ha ez az autó még nincs gold_enriched állapotban!
                     query = text("""
-                        INSERT INTO data.gb_catalog_discovery (vrm, make, model)
+                        INSERT INTO vehicle.gb_catalog_discovery (vrm, make, model)
                         SELECT :vrm, :make, :model
                         WHERE NOT EXISTS (
-                            SELECT 1 FROM data.vehicle_model_definitions 
+                            SELECT 1 FROM vehicle.vehicle_model_definitions
                             WHERE make = :make AND marketing_name = :model AND status = 'gold_enriched'
                         )
                         ON CONFLICT (vrm) DO NOTHING;

backend/app/workers/vehicle/vehicle_robot_0_strategist.py

@@ -63,7 +63,7 @@ class Robot0Strategist:
         # --- SÉMA ELLENŐRZÉS (Golyóálló megoldás) ---
         async with AsyncSessionLocal() as db:
             try:
-                await db.execute(text("ALTER TABLE data.catalog_discovery ADD COLUMN IF NOT EXISTS priority_score INTEGER DEFAULT 0;"))
+                await db.execute(text("ALTER TABLE vehicle.catalog_discovery ADD COLUMN IF NOT EXISTS priority_score INTEGER DEFAULT 0;"))
                 await db.commit()
                 logger.info("✅ Adatbázis séma rendben (priority_score aktív).")
             except Exception as e:
@@ -88,11 +88,11 @@ class Robot0Strategist:
                     try:
                         # UPSERT: Beállítjuk a prioritást, de nem bántjuk a már kész rekordokat
                         query = text("""
-                            INSERT INTO data.catalog_discovery (make, model, vehicle_class, status, source, attempts, priority_score)
+                            INSERT INTO vehicle.catalog_discovery (make, model, vehicle_class, status, source, attempts, priority_score)
                             VALUES (:make, 'ALL_VARIANTS', :class, 'pending', 'STRATEGIST-V2', 0, :score)
-                            ON CONFLICT (make, model, vehicle_class) 
-                            DO UPDATE SET priority_score = :score 
-                            WHERE data.catalog_discovery.status NOT IN ('processed', 'in_progress');
+                            ON CONFLICT (make, model, vehicle_class)
+                            DO UPDATE SET priority_score = :score
+                            WHERE vehicle.catalog_discovery.status NOT IN ('processed', 'in_progress');
                         """)
                         
                         await db.execute(query, {"make": make_name, "class": v_class, "score": count})

backend/app/workers/vehicle/vehicle_robot_1_2_nhtsa_fetcher.py

@@ -16,7 +16,7 @@ class NHTSAFetcher:
         """Lekéri azokat a márkákat, amik már benne vannak az adatbázisban EU-s forrásból."""
         async with AsyncSessionLocal() as db:
             # Csak azokat a márkákat keressük az USA-ban, amiket az EU-ban (RDW) már láttunk
-            query = text("SELECT DISTINCT make FROM data.catalog_discovery WHERE market = 'EU' OR source = 'RDW'")
+            query = text("SELECT DISTINCT make FROM vehicle.catalog_discovery WHERE market = 'EU' OR source = 'RDW'")
             res = await db.execute(query)
             return [row[0] for row in res.fetchall()]
 
@@ -47,7 +47,7 @@ class NHTSAFetcher:
                                     model_name = m.get("Model_Name").upper().strip()
                                     # USA_IMPORT jelölés, de csak EU-s márkákhoz!
                                     query = text("""
-                                        INSERT INTO data.catalog_discovery 
+                                        INSERT INTO vehicle.catalog_discovery
                                         (make, model, vehicle_class, status, market, model_year, priority_score, source)
                                         VALUES (:make, :model, 'car', 'pending', 'USA_IMPORT', :year, 5, 'NHTSA-EU-FILTERED')
                                         ON CONFLICT ON CONSTRAINT _make_model_market_year_uc DO NOTHING

backend/app/workers/vehicle/vehicle_robot_1_4_bike_hunter.py

@@ -35,7 +35,7 @@ class BikeHunter:
                                 model_name = m.get("Model_Name").upper().strip()
                                 # TISZTA SQL - Nincs Simon!
                                 query = text("""
-                                    INSERT INTO data.catalog_discovery 
+                                    INSERT INTO vehicle.catalog_discovery
                                     (make, model, vehicle_class, status, market, model_year, priority_score, source)
                                     VALUES (:make, :model, 'motorcycle', 'pending', 'USA_IMPORT', :year, 8, 'NHTSA-V1-BIKE')
                                     ON CONFLICT ON CONSTRAINT _make_model_market_year_uc DO NOTHING

backend/app/workers/vehicle/vehicle_robot_1_5_heavy_eu.py

@@ -51,7 +51,7 @@ class HeavyEUHunter:
 
                     # Szűrés a kért EU márkákra + amik jönnek az RDW-ből
                     query = text("""
-                        INSERT INTO data.catalog_discovery 
+                        INSERT INTO vehicle.catalog_discovery
                         (make, model, vehicle_class, status, market, priority_score, source)
                         VALUES (:make, :model, :v_class, 'pending', 'EU', 20, 'RDW-HEAVY')
                         ON CONFLICT ON CONSTRAINT _make_model_market_year_uc DO NOTHING

backend/app/workers/vehicle/vehicle_robot_1_catalog_hunter.py

@@ -173,7 +173,7 @@ class CatalogHunter:
                 await asyncio.sleep(0.5) # Lassítjuk kicsit a terhelést
             
             # Discovery státusz frissítése
-            await db.execute(text("UPDATE data.catalog_discovery SET status = 'processed' WHERE id = :id"), {"id": task_id})
+            await db.execute(text("UPDATE vehicle.catalog_discovery SET status = 'processed' WHERE id = :id"), {"id": task_id})
             await db.commit()
 
     @classmethod
@@ -184,10 +184,10 @@ class CatalogHunter:
                 # ATOMI ZÁROLÁS (Race condition ellenszere)
                 # Keresünk egy pending feladatot, azonnal zároljuk és átállítjuk processingre!
                 query = text("""
-                    UPDATE data.catalog_discovery
+                    UPDATE vehicle.catalog_discovery
                     SET status = 'processing'
                     WHERE id = (
-                        SELECT id FROM data.catalog_discovery
+                        SELECT id FROM vehicle.catalog_discovery
                         WHERE status = 'pending'
                         ORDER BY priority_score DESC
                         FOR UPDATE SKIP LOCKED

backend/app/workers/vehicle/vehicle_robot_1_gb_hunter.py

@@ -101,13 +101,13 @@ class GBHunter:
             
         if data == "NOT_FOUND":
             # Hibás volt a CSV rendszám, lezárjuk a feladatot
-            await db.execute(text("UPDATE data.gb_catalog_discovery SET status = 'invalid_vrm' WHERE id = :id"), {"id": record_id})
+            await db.execute(text("UPDATE vehicle.gb_catalog_discovery SET status = 'invalid_vrm' WHERE id = :id"), {"id": record_id})
             await db.commit()
             return "DONE"
             
         if not data:
             # Hálózati hiba, visszateszük a sorba
-            await db.execute(text("UPDATE data.gb_catalog_discovery SET status = 'pending' WHERE id = :id"), {"id": record_id})
+            await db.execute(text("UPDATE vehicle.gb_catalog_discovery SET status = 'pending' WHERE id = :id"), {"id": record_id})
             await db.commit()
             return "ERROR"
 
@@ -121,7 +121,7 @@ class GBHunter:
 
         # Beszúrás a Mestertáblába (A hiányzó lóerőt majd az Alkimista megszerzi!)
         query_vmd = text("""
-            INSERT INTO data.vehicle_model_definitions 
+            INSERT INTO vehicle.vehicle_model_definitions
             (make, marketing_name, vehicle_class, fuel_type, engine_capacity, co2_emissions_combined, year_from, type_approval_number, status, source)
             VALUES (:make, :model, 'car', :fuel, :ccm, :co2, :year, :approval, 'ACTIVE', 'GB-DVLA-API')
             ON CONFLICT (make, normalized_name, variant_code, version_code, fuel_type) DO NOTHING;
@@ -139,14 +139,14 @@ class GBHunter:
             })
             
             # Pipáljuk a feladatot
-            await db.execute(text("UPDATE data.gb_catalog_discovery SET status = 'processed' WHERE id = :id"), {"id": record_id})
+            await db.execute(text("UPDATE vehicle.gb_catalog_discovery SET status = 'processed' WHERE id = :id"), {"id": record_id})
             await db.commit()
             logger.info(f"✅ GB Rekord mentve a VMD táblába: {dvla_make} {model_csv} ({ccm}cc {fuel})")
             return "DONE"
         except Exception as e:
             await db.rollback()
             logger.error(f"🚨 Adatbázis hiba mentéskor: {e}")
-            await db.execute(text("UPDATE data.gb_catalog_discovery SET status = 'pending' WHERE id = :id"), {"id": record_id})
+            await db.execute(text("UPDATE vehicle.gb_catalog_discovery SET status = 'pending' WHERE id = :id"), {"id": record_id})
             await db.commit()
             return "ERROR"
 
@@ -160,10 +160,10 @@ class GBHunter:
                 async with AsyncSessionLocal() as db:
                     # ATOMI ZÁROLÁS
                     query = text("""
-                        UPDATE data.gb_catalog_discovery
+                        UPDATE vehicle.gb_catalog_discovery
                         SET status = 'processing'
                         WHERE id = (
-                            SELECT id FROM data.gb_catalog_discovery
+                            SELECT id FROM vehicle.gb_catalog_discovery
                             WHERE status = 'pending'
                             FOR UPDATE SKIP LOCKED
                             LIMIT 1

backend/app/workers/vehicle/vehicle_robot_2_researcher.py

@@ -82,6 +82,45 @@ class VehicleResearcher:
             logger.debug(f"Keresési hiba ({label}): {e}")
             return f"[SOURCE: {label}]\nKERESÉSI HIBA.\n"
 
+    def extract_specs_from_text(self, text: str) -> dict:
+        """ Regex alapú kinyerés a nyers szövegből: ccm, kW, motoradatok. """
+        import re
+        specs = {}
+        
+        # CCM (köbcentiméter) minta: 1998 cc, 2.0 L, 2000 cm³
+        ccm_pattern = r'(\d{3,4})\s*(?:cc|ccm|cm³|cm3|cc\.)'
+        match = re.search(ccm_pattern, text, re.IGNORECASE)
+        if match:
+            specs['ccm'] = int(match.group(1))
+        else:
+            # Alternatív minta: 2.0 liter -> 2000 cc
+            liter_pattern = r'(\d+\.?\d*)\s*(?:L|liter|ℓ)'
+            match = re.search(liter_pattern, text, re.IGNORECASE)
+            if match:
+                liters = float(match.group(1))
+                specs['ccm'] = int(liters * 1000)
+        
+        # KW (kilowatt) minta: 150 kW, 150kW, 150 KW
+        kw_pattern = r'(\d{2,4})\s*(?:kW|kw|KW)'
+        match = re.search(kw_pattern, text, re.IGNORECASE)
+        if match:
+            specs['kw'] = int(match.group(1))
+        else:
+            # Le (lóerő) átváltás: 150 LE -> 110 kW (kb)
+            hp_pattern = r'(\d{2,4})\s*(?:HP|hp|LE|le|Ps)'
+            match = re.search(hp_pattern, text, re.IGNORECASE)
+            if match:
+                hp = int(match.group(1))
+                specs['kw'] = int(hp * 0.7355)  # hozzávetőleges átváltás
+        
+        # Motor kód minta: motor kód: 1.8 TSI, engine code: N47
+        engine_pattern = r'(?:motor\s*kód|engine\s*code|motor\s*code)[:\s]+([A-Z0-9\.\- ]+)'
+        match = re.search(engine_pattern, text, re.IGNORECASE)
+        if match:
+            specs['engine_code'] = match.group(1).strip()
+        
+        return specs
+
     async def research_vehicle(self, db, vehicle_id: int, make: str, model: str, engine: str, year: str, current_attempts: int):
         """ Egy jármű átvilágítása és a strukturált 'Akta' elkészítése a GPU számára. """
         engine_safe = engine or ""
@@ -111,6 +150,9 @@ class VehicleResearcher:
         if len(full_context) > 2500:
             full_context = full_context[:2500] + "\n...[TRUNCATED TO SAVE GPU TOKENS]"
         
+        # Regex alapú specifikáció kinyerés
+        extracted_specs = self.extract_specs_from_text(full_context)
+        
         try:
             if len(full_context.strip()) > 150: # Csökkentettük az elvárást, mert a célzott keresés tömörebb
                 await db.execute(
@@ -118,6 +160,7 @@ class VehicleResearcher:
                     .where(VehicleModelDefinition.id == vehicle_id)
                     .values(
                         raw_search_context=full_context,
+                        research_metadata=extracted_specs,
                         status='awaiting_ai_synthesis', # Kész az Akta, mehet az Alkimistának!
                         last_research_at=func.now(),
                         attempts=current_attempts + 1
@@ -155,14 +198,15 @@ class VehicleResearcher:
                 async with AsyncSessionLocal() as db:
                     # ATOMI ZÁROLÁS
                     query = text("""
-                        UPDATE data.vehicle_model_definitions
+                        UPDATE vehicle.vehicle_model_definitions
                         SET status = 'research_in_progress'
                         WHERE id = (
-                            SELECT id FROM data.vehicle_model_definitions
+                            SELECT id FROM vehicle.vehicle_model_definitions
                             WHERE status IN ('unverified', 'awaiting_research', 'ACTIVE')
                               AND attempts < :max_attempts
-                            ORDER BY 
-                                CASE WHEN make = 'TOYOTA' THEN 1 ELSE 2 END, 
+                              AND is_manual = FALSE
+                            ORDER BY
+                                CASE WHEN make = 'TOYOTA' THEN 1 ELSE 2 END,
                                 attempts ASC
                             FOR UPDATE SKIP LOCKED
                             LIMIT 1

backend/app/workers/vehicle/vehicle_robot_3_alchemist_pro.py

@@ -97,7 +97,7 @@ class TechEnricher:
             clean_model = str(ai_data.get("marketing_name", base_info['m_name']))[:50].upper()
             
             cat_stmt = text("""
-                INSERT INTO data.vehicle_catalog 
+                INSERT INTO vehicle.vehicle_catalog
                 (master_definition_id, make, model, power_kw, engine_capacity, fuel_type, factory_data)
                 VALUES (:m_id, :make, :model, :kw, :ccm, :fuel, :factory)
                 ON CONFLICT ON CONSTRAINT uix_vehicle_catalog_full DO NOTHING
@@ -173,19 +173,20 @@ class TechEnricher:
                 async with AsyncSessionLocal() as db:
                     # ATOMI ZÁROLÁS (A "Szent Grál" a race condition ellen)
                     query = text("""
-                        UPDATE data.vehicle_model_definitions
+                        UPDATE vehicle.vehicle_model_definitions
                         SET status = 'ai_synthesis_in_progress'
                         WHERE id = (
-                            SELECT id FROM data.vehicle_model_definitions
+                            SELECT id FROM vehicle.vehicle_model_definitions
                             WHERE status IN ('awaiting_ai_synthesis', 'ACTIVE')
                               AND attempts < :max_attempts
-                            ORDER BY 
+                              AND is_manual = FALSE
+                            ORDER BY
                                 CASE WHEN status = 'awaiting_ai_synthesis' THEN 1 ELSE 2 END,
                                 priority_score DESC
                             FOR UPDATE SKIP LOCKED
                             LIMIT 1
                         )
-                        RETURNING id, make, marketing_name, vehicle_class, power_kw, engine_capacity, 
+                        RETURNING id, make, marketing_name, vehicle_class, power_kw, engine_capacity,
                                   fuel_type, engine_code, euro_classification, cylinders, raw_search_context, attempts;
                     """)
                     

backend/app/workers/vehicle/vehicle_robot_4_vin_auditor.py

@@ -86,10 +86,10 @@ class VINAuditor:
                 async with AsyncSessionLocal() as db:
                     # ATOMI ZÁROLÁS (Asset táblán)
                     query = text("""
-                        UPDATE data.assets
+                        UPDATE vehicle.assets
                         SET status = 'audit_in_progress'
                         WHERE id = (
-                            SELECT id FROM data.assets
+                            SELECT id FROM vehicle.assets
                             WHERE is_verified = false 
                               AND vin IS NOT NULL
                               AND status NOT IN ('audit_in_progress', 'audit_failed')