238 lines
8.8 KiB
Python
Executable File
238 lines
8.8 KiB
Python
Executable File
# /opt/docker/dev/service_finder/backend/app/api/v1/endpoints/admin.py
|
|
from fastapi import APIRouter, Depends, HTTPException, status
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy import select, func, text, delete
|
|
from typing import List, Any, Dict, Optional
|
|
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, 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 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: ParameterScope = ParameterScope.GLOBAL
|
|
scope_id: Optional[str] = None
|
|
category: str = "general"
|
|
|
|
router = APIRouter()
|
|
|
|
async def check_admin_access(current_user: User = Depends(deps.get_current_active_user)):
|
|
""" Csak Admin vagy Superadmin. """
|
|
if current_user.role not in [UserRole.admin, UserRole.superadmin]:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_403_FORBIDDEN,
|
|
detail="Sentinel jogosultság szükséges!"
|
|
)
|
|
return current_user
|
|
|
|
@router.get("/health-monitor", tags=["Sentinel Monitoring"])
|
|
async def get_system_health(
|
|
db: AsyncSession = Depends(deps.get_db),
|
|
admin: User = Depends(check_admin_access)
|
|
):
|
|
stats = {}
|
|
|
|
# Adatbázis statisztikák (Nyers SQL marad, mert hatékony)
|
|
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 vehicle.assets"))
|
|
stats["total_assets"] = asset_count.scalar()
|
|
|
|
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
|
|
day_ago = datetime.now() - timedelta(days=1)
|
|
crit_logs = await db.execute(
|
|
select(func.count(SecurityAuditLog.id))
|
|
.where(
|
|
SecurityAuditLog.is_critical == True,
|
|
SecurityAuditLog.created_at >= day_ago
|
|
)
|
|
)
|
|
stats["critical_alerts_24h"] = crit_logs.scalar() or 0
|
|
|
|
return stats
|
|
|
|
@router.get("/pending-actions", response_model=List[Any], tags=["Sentinel Security"])
|
|
async def list_pending_actions(
|
|
db: AsyncSession = Depends(deps.get_db),
|
|
admin: User = Depends(check_admin_access)
|
|
):
|
|
stmt = select(PendingAction).where(PendingAction.status == ActionStatus.pending)
|
|
result = await db.execute(stmt)
|
|
return result.scalars().all()
|
|
|
|
@router.post("/approve/{action_id}", tags=["Sentinel Security"])
|
|
async def approve_action(
|
|
action_id: int,
|
|
db: AsyncSession = Depends(deps.get_db),
|
|
admin: User = Depends(check_admin_access)
|
|
):
|
|
try:
|
|
await security_service.approve_action(db, admin.id, action_id)
|
|
return {"status": "success", "message": "Művelet végrehajtva."}
|
|
except Exception as e:
|
|
raise HTTPException(status_code=400, detail=str(e))
|
|
|
|
@router.get("/parameters", tags=["Dynamic Configuration"])
|
|
async def list_all_parameters(
|
|
db: AsyncSession = Depends(deps.get_db),
|
|
admin: User = Depends(check_admin_access)
|
|
):
|
|
result = await db.execute(select(SystemParameter))
|
|
return result.scalars().all()
|
|
|
|
@router.post("/parameters", tags=["Dynamic Configuration"])
|
|
async def set_parameter(
|
|
config: ConfigUpdate,
|
|
db: AsyncSession = Depends(deps.get_db),
|
|
admin: User = Depends(check_admin_access)
|
|
):
|
|
query = text("""
|
|
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
|
|
value = EXCLUDED.value,
|
|
category = EXCLUDED.category,
|
|
last_modified_by = EXCLUDED.last_modified_by,
|
|
updated_at = now()
|
|
""")
|
|
|
|
await db.execute(query, {
|
|
"key": config.key,
|
|
"val": config.value,
|
|
"sl": config.scope_level,
|
|
"sid": config.scope_id,
|
|
"cat": config.category,
|
|
"user": admin.email
|
|
})
|
|
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."}
|
|
|
|
|
|
# ==================== 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
|
|
} |