feat: implement hybrid address system and premium search logic

- Added centralized, self-learning GeoService (ZIP, City, Street)
- Implemented Hybrid Address Management (Centralized table + Denormalized fields)
- Fixed Gamification logic (PointsLedger field names & filtering)
- Added address autocomplete and two-tier (Free/Premium) search API
- Synchronized UserStats and PointsLedger schemas

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

@@ -1,48 +1,75 @@
 from fastapi import APIRouter, Depends, HTTPException, status
 from fastapi.security import OAuth2PasswordRequestForm
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import text
+from sqlalchemy import select
 
 from app.db.session import get_db
 from app.services.auth_service import AuthService
 from app.core.security import create_access_token
-from app.schemas.auth import UserLiteRegister, Token, PasswordResetRequest, UserKYCComplete
-from app.api.deps import get_current_user # Ez kezeli a belépett felhasználót
+from app.schemas.auth import (
+    UserLiteRegister, Token, PasswordResetRequest, 
+    UserKYCComplete, PasswordResetConfirm
+)
+from app.api.deps import get_current_user
 from app.models.identity import User
 
 router = APIRouter()
 
-@router.post("/register-lite", response_model=Token, status_code=201)
+@router.post("/register-lite", response_model=Token, status_code=status.HTTP_201_CREATED)
 async def register_lite(user_in: UserLiteRegister, db: AsyncSession = Depends(get_db)):
-    """Step 1: Alapszintű regisztráció és aktiváló e-mail küldése."""
-    check = await db.execute(text("SELECT id FROM data.users WHERE email = :e"), {"e": user_in.email})
-    if check.fetchone():
-        raise HTTPException(status_code=400, detail="Ez az email cím már foglalt.")
+    """Step 1: Alapszintű regisztráció (Email + Jelszó)."""
+    stmt = select(User).where(User.email == user_in.email)
+    result = await db.execute(stmt)
+    if result.scalar_one_or_none():
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, 
+            detail="Ez az e-mail cím már regisztrálva van."
+        )
     
     try:
         user = await AuthService.register_lite(db, user_in)
         token = create_access_token(data={"sub": str(user.id)})
-        return {"access_token": token, "token_type": "bearer", "is_active": user.is_active}
+        return {
+            "access_token": token, 
+            "token_type": "bearer", 
+            "is_active": user.is_active
+        }
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Szerver hiba: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, 
+            detail=f"Sikertelen regisztráció: {str(e)}"
+        )
 
 @router.post("/login", response_model=Token)
-async def login(form_data: OAuth2PasswordRequestForm = Depends(), db: AsyncSession = Depends(get_db)):
-    """Bejelentkezés az access_token megszerzéséhez."""
+async def login(
+    db: AsyncSession = Depends(get_db), 
+    form_data: OAuth2PasswordRequestForm = Depends()
+):
+    """Bejelentkezés és Access Token generálása."""
     user = await AuthService.authenticate(db, form_data.username, form_data.password)
     if not user:
-        raise HTTPException(status_code=401, detail="Hibás e-mail vagy jelszó.")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, 
+            detail="Hibás e-mail cím vagy jelszó."
+        )
     
     token = create_access_token(data={"sub": str(user.id)})
-    return {"access_token": token, "token_type": "bearer", "is_active": user.is_active}
+    return {
+        "access_token": token, 
+        "token_type": "bearer", 
+        "is_active": user.is_active
+    }
 
 @router.get("/verify-email")
 async def verify_email(token: str, db: AsyncSession = Depends(get_db)):
-    """E-mail megerősítése a kiküldött token alapján."""
+    """E-mail megerősítése a kiküldött link alapján."""
     success = await AuthService.verify_email(db, token)
     if not success:
-        raise HTTPException(status_code=400, detail="Érvénytelen vagy lejárt token.")
-    return {"message": "Email sikeresen megerősítve! Jöhet a Step 2 (KYC)."}
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, 
+            detail="Érvénytelen vagy lejárt megerősítő token."
+        )
+    return {"message": "Email sikeresen megerősítve! Jöhet a profil kitöltése (KYC)."}
 
 @router.post("/complete-kyc")
 async def complete_kyc(
@@ -50,14 +77,38 @@ async def complete_kyc(
     db: AsyncSession = Depends(get_db),
     current_user: User = Depends(get_current_user)
 ):
-    """Step 2: Okmányok rögzítése, Privát Széf és Wallet aktiválása."""
+    """Step 2: Személyes adatok és okmányok rögzítése."""
     user = await AuthService.complete_kyc(db, current_user.id, kyc_in)
     if not user:
-        raise HTTPException(status_code=404, detail="Felhasználó nem található.")
-    return {"status": "success", "message": "Gratulálunk! A Privát Széf és a Pénztárca aktiválva lett."}
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Felhasználó nem található.")
+    return {"status": "success", "message": "A profil adatok rögzítve, a rendszer aktiválva."}
 
 @router.post("/forgot-password")
 async def forgot_password(req: PasswordResetRequest, db: AsyncSession = Depends(get_db)):
-    """Jelszó-visszaállító link küldése."""
-    await AuthService.initiate_password_reset(db, req.email)
-    return {"message": "Ha a cím létezik, elküldtük a helyreállítási linket."}
+    """Elfelejtett jelszó folyamat indítása biztonsági korlátokkal."""
+    result = await AuthService.initiate_password_reset(db, req.email)
+    
+    if result == "cooldown":
+        raise HTTPException(status_code=429, detail="Kérjük várjon 2 percet az újabb kérés előtt.")
+    if result in ["hourly_limit", "daily_limit"]:
+        raise HTTPException(status_code=429, detail="Túllépte a napi/óránkénti próbálkozások számát.")
+    
+    return {"message": "Amennyiben a megadott e-mail cím szerepel a rendszerünkben, kiküldtük a linket."}
+
+@router.post("/reset-password")
+async def reset_password(req: PasswordResetConfirm, db: AsyncSession = Depends(get_db)):
+    """Új jelszó beállítása. Backend ellenőrzi az egyezőséget és a tokent."""
+    if req.password != req.password_confirm:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, 
+            detail="A két jelszó nem egyezik meg."
+        )
+    
+    success = await AuthService.reset_password(db, req.email, req.token, req.password)
+    if not success:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, 
+            detail="Érvénytelen adatok vagy lejárt token."
+        )
+        
+    return {"message": "A jelszó sikeresen frissítve! Most már bejelentkezhet."}