added uuid generation and token creation

now using token for authentication instead of password and username

app.py

@@ -1,6 +1,7 @@
 import asyncio
 import json
 import secrets
+import uuid
 from datetime import datetime
 from pathlib import Path
 
@@ -94,22 +95,45 @@ def register_user(username: str, password: str):
     if username in users:
         raise HTTPException(status_code=400, detail="User already exists")
     hashed = ph.hash(password)
-    users[username] = hashed
+    user_id = str(uuid.uuid4())
+    token = secrets.token_hex(32)
+    users[username] = {
+        "userId": user_id,
+        "password": hashed,
+        "token": token,
+    }
     save_json(USERS_FILE, users)
+    return token
 
 
-def verify_user(username: str, password: str):
+def verify_token(token: str):
+    users = load_json(USERS_FILE)
+    for username, user in users.items():
+        if user.get("token") == token:
+            return username
+    return None
+
+
+def verify_user_password(username: str, password: str):
     users = load_json(USERS_FILE)
     if username not in users:
         return False
     try:
-        ph.verify(users[username], password)
+        ph.verify(users[username]["password"], password)
         return True
     except Exception as e:
         print(f"Verification error: {e}")
         return False
 
 
+def get_user_token(username: str):
+    users = load_json(USERS_FILE)
+    user = users.get(username)
+    if user:
+        return user.get("token")
+    return None
+
+
 # ---------------------- Glares System ---------------------- #
 
 
@@ -150,21 +174,25 @@ def update_user_glares(username: str, earnings: float):
 
 @app.post("/register")
 def register(username: str = Form(...), password: str = Form(...)):
-    register_user(username, password)
-    return JSONResponse(content={"message": "User registered successfully"})
+    token = register_user(username, password)
+    return JSONResponse(
+        content={"message": "User registered successfully", "token": token}
+    )
 
 
 @app.post("/login")
 def login(username: str = Form(...), password: str = Form(...)):
-    if verify_user(username, password):
-        return JSONResponse(content={"message": "Login successful"})
+    if verify_user_password(username, password):
+        token = get_user_token(username)
+        return JSONResponse(content={"message": "Login successful", "token": token})
     raise HTTPException(status_code=401, detail="Invalid credentials")
 
 
 @app.get("/glares")
-def get_glares(username: str, password: str):
-    if not verify_user(username, password):
-        raise HTTPException(status_code=401, detail="Invalid credentials")
+def get_glares(token: str):
+    username = verify_token(token)
+    if not username:
+        raise HTTPException(status_code=401, detail="Invalid token")
     current = get_updated_glares(username)
     return {"username": username, "glares": current}
 
@@ -179,11 +207,10 @@ async def coinflip(websocket: WebSocket):
     try:
         # First message must be auth
         auth = await websocket.receive_json()
-        username = auth.get("username")
-        password = auth.get("password")
-
-        if not username or not password or not verify_user(username, password):
-            await websocket.send_json({"error": "Invalid credentials"})
+        token = auth.get("token")
+        username = verify_token(token)
+        if not username:
+            await websocket.send_json({"error": "Invalid token"})
             await websocket.close()
             return
 
@@ -249,11 +276,10 @@ async def roulette(websocket: WebSocket):
     try:
         # First message must be auth
         auth = await websocket.receive_json()
-        username = auth.get("username")
-        password = auth.get("password")
-
-        if not username or not password or not verify_user(username, password):
-            await websocket.send_json({"error": "Invalid credentials"})
+        token = auth.get("token")
+        username = verify_token(token)
+        if not username:
+            await websocket.send_json({"error": "Invalid token"})
             await websocket.close()
             return
 
@@ -439,11 +465,10 @@ async def spinner(websocket: WebSocket):
     try:
         # First message must be auth
         auth = await websocket.receive_json()
-        username = auth.get("username")
-        password = auth.get("password")
-
-        if not username or not password or not verify_user(username, password):
-            await websocket.send_json({"error": "Invalid credentials"})
+        token = auth.get("token")
+        username = verify_token(token)
+        if not username:
+            await websocket.send_json({"error": "Invalid token"})
             await websocket.close()
             return
 
@@ -490,11 +515,10 @@ async def crash(websocket: WebSocket):
     try:
         # First message must be auth
         auth = await websocket.receive_json()
-        username = auth.get("username")
-        password = auth.get("password")
-
-        if not username or not password or not verify_user(username, password):
-            await websocket.send_json({"error": "Invalid credentials"})
+        token = auth.get("token")
+        username = verify_token(token)
+        if not username:
+            await websocket.send_json({"error": "Invalid token"})
             await websocket.close()
             return
 
@@ -583,11 +607,10 @@ async def mines(websocket: WebSocket):
     try:
         # First message must be auth
         auth = await websocket.receive_json()
-        username = auth.get("username")
-        password = auth.get("password")
-
-        if not username or not password or not verify_user(username, password):
-            await websocket.send_json({"error": "Invalid credentials"})
+        token = auth.get("token")
+        username = verify_token(token)
+        if not username:
+            await websocket.send_json({"error": "Invalid token"})
             await websocket.close()
             return
 
@@ -678,11 +701,10 @@ async def tower(websocket: WebSocket):
     try:
         # First message must be auth
         auth = await websocket.receive_json()
-        username = auth.get("username")
-        password = auth.get("password")
-
-        if not username or not password or not verify_user(username, password):
-            await websocket.send_json({"error": "Invalid credentials"})
+        token = auth.get("token")
+        username = verify_token(token)
+        if not username:
+            await websocket.send_json({"error": "Invalid token"})
             await websocket.close()
             return
 
@@ -727,16 +749,27 @@ async def tower(websocket: WebSocket):
                         if position not in [0, 1, 2, 3]:
                             await websocket.send_json({"error": "Invalid position"})
                             continue
-                        if position in safe_positions:
-                            level += 1
-                            multiplier += 1 / 4 * 0.99
-                            safe_positions.remove(position)
-                            await websocket.send_json(
-                                {
-                                    "level": level,
-                                    "multiplier": round(multiplier, 2),
-                                }
-                            )
+                        if position == safe_positions[level]:
+                            if level < 8:
+                                level += 1
+                                multiplier += 3 / 4 * 0.99
+                                safe_positions.remove(position)
+                                await websocket.send_json(
+                                    {
+                                        "level": level,
+                                        "multiplier": round(multiplier, 2),
+                                    }
+                                )
+                            else:
+                                multiplier += 3 / 4 * 0.99
+                                await websocket.send_json(
+                                    {
+                                        "level": level,
+                                        "multiplier": round(multiplier, 2),
+                                        "completed": True,
+                                    }
+                                )
+                                break
                         else:
                             multiplier = 0
                             break
@@ -773,11 +806,10 @@ async def blackjack(websocket: WebSocket):
     try:
         # First message must be auth
         auth = await websocket.receive_json()
-        username = auth.get("username")
-        password = auth.get("password")
-
-        if not username or not password or not verify_user(username, password):
-            await websocket.send_json({"error": "Invalid credentials"})
+        token = auth.get("token")
+        username = verify_token(token)
+        if not username:
+            await websocket.send_json({"error": "Invalid token"})
             await websocket.close()
             return
 
@@ -883,11 +915,10 @@ async def hilo(websocket: WebSocket):
     try:
         # First message must be auth
         auth = await websocket.receive_json()
-        username = auth.get("username")
-        password = auth.get("password")
-
-        if not username or not password or not verify_user(username, password):
-            await websocket.send_json({"error": "Invalid credentials"})
+        token = auth.get("token")
+        username = verify_token(token)
+        if not username:
+            await websocket.send_json({"error": "Invalid token"})
             await websocket.close()
             return
 

client.py

@@ -24,9 +24,11 @@ else:
 
 USERNAME = "testuser"
 PASSWORD = "testpass"
+TOKEN = None
 
 
 async def register_user():
+    global TOKEN
     async with aiohttp.ClientSession() as session:
         data = {"username": USERNAME, "password": PASSWORD}
         async with session.post(f"{API_URL}/register", data=data) as resp:
@@ -34,15 +36,24 @@ async def register_user():
             if resp.status != 200:
                 text = await resp.text()
                 print(f"Register failed (maybe already registered): {text}")
+                # Try login if already registered
+                async with session.post(f"{API_URL}/login", data=data) as login_resp:
+                    if login_resp.status == 200:
+                        res = await login_resp.json()
+                        TOKEN = res.get("token")
+                        print(f"Login response: {res}")
+                    else:
+                        print(f"Login failed: {await login_resp.text()}")
             else:
                 res = await resp.json()
+                TOKEN = res.get("token")
                 print(f"Register response: {res}")
 
 
 async def play_roulette():
     async with websockets.connect(WS_URL_ROULETTE) as websocket:
         # Send authentication
-        auth_msg = {"username": USERNAME, "password": PASSWORD}
+        auth_msg = {"token": TOKEN}
         await websocket.send(json.dumps(auth_msg))
         # Receive welcome message with balance
         welcome = await websocket.recv()
@@ -73,8 +84,11 @@ async def play_roulette():
 async def play_spinner():
     # First get current balance to bet all-in
     async with aiohttp.ClientSession() as session:
-        params = {"username": USERNAME, "password": PASSWORD}
-        async with session.get(f"{API_URL}/glares", params=params) as resp:
+        params = {k: v for k, v in {"token": TOKEN}.items() if v is not None}
+        filtered_params = {
+            k: str(v) for k, v in params.items()
+        }  # Ensure all values are strings
+        async with session.get(f"{API_URL}/glares", params=filtered_params) as resp:
             balance_data = await resp.json()
             balance = balance_data.get("glares", 0)
             print(f"Current balance: {balance}")
@@ -82,7 +96,7 @@ async def play_spinner():
     # Now connect to spinner and bet all-in
     async with websockets.connect(WS_URL_SPINNER) as websocket:
         # Send authentication
-        auth_msg = {"username": USERNAME, "password": PASSWORD}
+        auth_msg = {"token": TOKEN}
         await websocket.send(json.dumps(auth_msg))
 
         # Receive welcome message
@@ -119,8 +133,9 @@ async def play_crash():
     """Play the crash game and cash out after 2 seconds"""
     # Get balance first
     async with aiohttp.ClientSession() as session:
-        params = {"username": USERNAME, "password": PASSWORD}
-        async with session.get(f"{API_URL}/glares", params=params) as resp:
+        params = {k: v for k, v in {"token": TOKEN}.items() if v is not None}
+        filtered_params = {k: v for k, v in params.items() if v is not None}
+        async with session.get(f"{API_URL}/glares", params=filtered_params) as resp:
             balance_data = await resp.json()
             balance = balance_data.get("glares", 0)
             print(f"Current balance before crash: {balance}")
@@ -128,7 +143,7 @@ async def play_crash():
     # Connect to crash game
     async with websockets.connect(WS_URL_CRASH) as websocket:
         # Send authentication
-        auth_msg = {"username": USERNAME, "password": PASSWORD}
+        auth_msg = {"token": TOKEN}
         await websocket.send(json.dumps(auth_msg))
 
         # Receive welcome message
@@ -190,8 +205,9 @@ async def play_mines():
     """Play the mines game with random placements and cash out after 5 reveals"""
     # Get balance first
     async with aiohttp.ClientSession() as session:
-        params = {"username": USERNAME, "password": PASSWORD}
-        async with session.get(f"{API_URL}/glares", params=params) as resp:
+        params = {"token": TOKEN}
+        filtered_params = {k: v for k, v in params.items() if v is not None}
+        async with session.get(f"{API_URL}/glares", params=filtered_params) as resp:
             balance_data = await resp.json()
             balance = balance_data.get("glares", 0)
             print(f"Current balance before mines: {balance}")
@@ -199,7 +215,7 @@ async def play_mines():
     # Connect to mines game
     async with websockets.connect(WS_URL_MINES) as websocket:
         # Send authentication
-        auth_msg = {"username": USERNAME, "password": PASSWORD}
+        auth_msg = {"token": TOKEN}
         await websocket.send(json.dumps(auth_msg))
 
         # Receive welcome message
@@ -270,8 +286,9 @@ async def play_tower():
     """Play the tower game with random tile selections and cash out after a random number of levels"""
     # Get balance first
     async with aiohttp.ClientSession() as session:
-        params = {"username": USERNAME, "password": PASSWORD}
-        async with session.get(f"{API_URL}/glares", params=params) as resp:
+        params = {"token": TOKEN}
+        filtered_params = {k: v for k, v in params.items() if v is not None}
+        async with session.get(f"{API_URL}/glares", params=filtered_params) as resp:
             balance_data = await resp.json()
             balance = balance_data.get("glares", 0)
             print(f"Current balance before tower: {balance}")
@@ -279,7 +296,7 @@ async def play_tower():
     # Connect to tower game
     async with websockets.connect(WS_URL_TOWER) as websocket:
         # Send authentication
-        auth_msg = {"username": USERNAME, "password": PASSWORD}
+        auth_msg = {"token": TOKEN}
         await websocket.send(json.dumps(auth_msg))
 
         # Receive welcome message