Merge branch 'main' of https://github.com/Alalalallalalalalalalalal/FinED-Front

phase/Student_view/chatbot.py

@@ -17,7 +17,11 @@ TUTOR_PROMPT = (
     "Teach step-by-step with tiny examples. Avoid giving personal financial advice."
 )
 
+# -------------------------------
+# History helpers
+# -------------------------------
 def _format_history_for_flan(messages: list[dict]) -> str:
+    """Format history for text-generation style models."""
     lines = []
     for m in messages:
         txt = (m.get("text") or "").strip()
@@ -26,14 +30,8 @@ def _format_history_for_flan(messages: list[dict]) -> str:
         lines.append(("Tutor" if m.get("sender") == "assistant" else "User") + f": {txt}")
     return "\n".join(lines)
 
-def _trim_turn(text: str) -> str:
-    for cp in ["\nUser:", "\nTutor:", "\nAssistant:", "\n###"]:
-        if cp in text:
-            return text.split(cp, 1)[0].strip()
-    return text.strip()
-
 def _history_as_chat_messages(messages: list[dict]) -> list[dict]:
-    # Convert your session history to HF chat format
+    """Convert history to chat-completion style messages."""
     msgs = [{"role": "system", "content": TUTOR_PROMPT}]
     for m in messages:
         txt = (m.get("text") or "").strip()
@@ -44,55 +42,53 @@ def _history_as_chat_messages(messages: list[dict]) -> list[dict]:
     return msgs
 
 def _extract_chat_text(chat_resp) -> str:
-    # Works for both dict-like and object-like responses
+    """Extract text from HF chat response."""
     try:
-        # huggingface_hub >= 0.23 style
-        return chat_resp.choices[0].message["content"] if isinstance(chat_resp.choices[0].message, dict) \
-            else chat_resp.choices[0].message.content
+        return chat_resp.choices[0].message["content"] if isinstance(
+            chat_resp.choices[0].message, dict
+        ) else chat_resp.choices[0].message.content
     except Exception:
-        # fallback for dict payloads
         try:
             return chat_resp["choices"][0]["message"]["content"]
         except Exception:
             return str(chat_resp)
 
+# -------------------------------
+# Reply logic
+# -------------------------------
 def _reply_with_hf():
     if "client" not in globals():
         raise RuntimeError("HF client not initialized")
 
-    # Text-generation prompt (for providers that support it)
-    convo = _format_history_for_flan(st.session_state.get("messages", []))
-    tg_prompt = f"{TUTOR_PROMPT}\n\n{convo}\n\nTutor:"
-
     try:
-        # 1) Try text-generation first (many backends support this)
-        resp = client.text_generation(
-            tg_prompt,
-            max_new_tokens=220,
+        # 1) Prefer chat API
+        msgs = _history_as_chat_messages(st.session_state.get("messages", []))
+        chat = client.chat.completions.create(
+            model=GEN_MODEL,
+            messages=msgs,
+            max_tokens=300,   # give enough room
             temperature=0.2,
             top_p=0.9,
-            repetition_penalty=1.1,
-            return_full_text=True,
-            stream=False,
         )
-        text = resp.get("generated_text") if isinstance(resp, dict) else resp
-        return _trim_turn(str(text or "").strip())
+        return _extract_chat_text(chat).strip()
 
     except ValueError as ve:
-        # 2) If the provider says "Supported task: conversational", use HF chat
-        if "Supported task: conversational" in str(ve):
-            msgs = _history_as_chat_messages(st.session_state.get("messages", []))
-            chat = client.chat.completions.create(
-                model=GEN_MODEL,          # still HF, not OpenAI
-                messages=msgs,
-                max_tokens=220,
+        # 2) Fallback to text-generation if chat unsupported
+        if "Supported task: text-generation" in str(ve):
+            convo = _format_history_for_flan(st.session_state.get("messages", []))
+            tg_prompt = f"{TUTOR_PROMPT}\n\n{convo}\n\nTutor:"
+            resp = client.text_generation(
+                tg_prompt,
+                max_new_tokens=300,
                 temperature=0.2,
                 top_p=0.9,
+                repetition_penalty=1.1,
+                return_full_text=True,
+                stream=False,
             )
-            return _trim_turn(_extract_chat_text(chat))
+            return (resp.get("generated_text") if isinstance(resp, dict) else resp).strip()
 
-        # Some other ValueError — rethrow with the original message
-        raise
+        raise  # rethrow anything else
 
     except Exception as e:
         err_text = ''.join(traceback.format_exception_only(type(e), e)).strip()

phase/Student_view/games/budgetbuilder.py

@@ -1,10 +1,70 @@
 # phase\Student_view\games\budgetbuilder.py
 
 import streamlit as st
+import os, time
+from utils import api as backend
 from utils import db as dbapi
 
+DISABLE_DB = os.getenv("DISABLE_DB", "1") == "1"
+
+def _refresh_global_xp():
+    user = st.session_state.get("user")
+    if not user:
+        return
+    try:
+        stats = backend.user_stats(user["user_id"]) if DISABLE_DB else dbapi.user_xp_and_level(user["user_id"])
+        st.session_state.xp = stats.get("xp", st.session_state.get("xp", 0))
+        st.session_state.streak = stats.get("streak", st.session_state.get("streak", 0))
+    except Exception as e:
+        st.warning(f"XP refresh failed: {e}")
+
+
+def _persist_budget_result(level_cfg: dict, success: bool, gained_xp: int):
+    user = st.session_state.get("user")
+    if not user:
+        st.info("Login to earn and save XP.")
+        return
+
+    try:
+        elapsed_ms = int((time.time() - st.session_state.get("bb_start_ts", time.time())) * 1000)
+        allocations = [{"id": cid, "amount": int(val)} for cid, val in st.session_state.categories.items()]
+        budget_score = 100 if success else 0
+
+        if DISABLE_DB:
+            backend.record_budget_builder_play(
+                user_id=user["user_id"],
+                weekly_allowance=int(level_cfg["income"]),
+                budget_score=int(budget_score),
+                elapsed_ms=elapsed_ms,
+                allocations=allocations,
+                gained_xp=int(gained_xp),
+            )
+        else:
+            # Local DB path (if your db layer has one of these)
+            if hasattr(dbapi, "record_budget_builder_result"):
+                dbapi.record_budget_builder_result(
+                    user_id=user["user_id"],
+                    weekly_allowance=int(level_cfg["income"]),
+                    budget_score=int(budget_score),
+                    elapsed_ms=elapsed_ms,
+                    allocations=allocations,
+                    gained_xp=int(gained_xp),
+                )
+            elif hasattr(dbapi, "award_xp"):
+                dbapi.award_xp(user["user_id"], int(gained_xp), reason="budget_builder")
+
+        _refresh_global_xp()  # <-- this makes the XP bar move immediately
+    except Exception as e:
+        st.warning(f"Could not save budget result: {e}")
+
 
 def show_budget_builder():
+
+    # timer for elapsed_ms
+    if "bb_start_ts" not in st.session_state:
+        st.session_state.bb_start_ts = time.time()
+
+
     # Add custom CSS for improved styling
     st.markdown("""
     <style>
@@ -392,6 +452,12 @@ def show_budget_builder():
                     st.session_state.level_completed = True
                     if level["id"] not in st.session_state.completed_levels:
                         st.session_state.completed_levels.append(level["id"])
+
+                    # award exactly once per level
+                    award_key = f"_bb_xp_awarded_L{level['id']}"
+                    if not st.session_state.get(award_key):
+                        _persist_budget_result(level, success=True, gained_xp=int(level["xp"]))
+                        st.session_state[award_key] = True
                 else:
                     st.error("❌ Not complete yet. Check the requirements!")
                     for desc, passed in results:
@@ -416,8 +482,10 @@ def show_budget_builder():
                 st.session_state.current_level += 1
                 st.session_state.categories = {cid: 0 for cid in categories_master.keys()}
                 st.session_state.level_completed = False
+                st.session_state.bb_start_ts = time.time()  # <-- reset timer
                 st.experimental_rerun()
 
+
     with right_col:
         criteria_html = ""
         for desc, fn in level["success"]:
@@ -486,4 +554,5 @@ def show_budget_builder():
             st.session_state.completed_levels = []
             st.session_state.categories = {cid: 0 for cid in categories_master.keys()}
             st.session_state.level_completed = False
+            st.session_state.bb_start_ts = time.time()  # <-- reset timer
             st.experimental_rerun()

phase/Student_view/games/debtdilemma.py

@@ -4,9 +4,11 @@ from dataclasses import dataclass, field
 from typing import List, Optional, Dict, Literal
 import random
 import math
-import os
+import os, time
+from utils import api as backend
 from utils import db as dbapi
 
+DISABLE_DB = os.getenv("DISABLE_DB", "1") == "1"
 
 def load_css(file_name: str):
     try:
@@ -16,6 +18,18 @@ def load_css(file_name: str):
         st.warning("⚠️ Stylesheet not found. Please ensure 'assets/styles.css' exists.")
 
 
+def _refresh_global_xp():
+    user = st.session_state.get("user")
+    if not user:
+        return
+    try:
+        stats = backend.user_stats(user["user_id"]) if DISABLE_DB else dbapi.user_xp_and_level(user["user_id"])
+        st.session_state.xp = stats.get("xp", st.session_state.get("xp", 0))
+        st.session_state.streak = stats.get("streak", st.session_state.get("streak", 0))
+    except Exception as e:
+        st.warning(f"XP refresh failed: {e}")
+
+
 DD_SCOPE_CLASS = "dd-scope"  
 
 def _ensure_dd_css():
@@ -278,19 +292,37 @@ def _award_level_completion_if_needed():
         return  # already awarded for this level
 
     try:
-        dbapi.record_debt_dilemma_round(
-            user["user_id"],
-            level=lvl,
-            round_no=0,
-            wallet=int(st.session_state.wallet),
-            health=int(st.session_state.health),
-            happiness=int(st.session_state.happiness),
-            credit_score=int(st.session_state.loan.creditScore),
-            event_json={"phase": st.session_state.gamePhase},
-            outcome="level_complete" if st.session_state.gamePhase == "level-complete" else "game_complete",
-            gained_xp=50
-        )
+        # compute elapsed time for the level
+        start_ts = st.session_state.get("dd_start_ts", time.time())
+        elapsed_ms = int(max(0, (time.time() - start_ts) * 1000))
+
+        if DISABLE_DB:
+            # call backend Space
+            backend.record_debt_dilemma_play(
+                user_id=user["user_id"],
+                loans_cleared=1,  # you completed the level
+                mistakes=int(st.session_state.loan.missedPayments),
+                elapsed_ms=elapsed_ms,
+                gained_xp=50,
+            )
+        else:
+            # local DB path kept for dev mode
+            dbapi.record_debt_dilemma_round(
+                user["user_id"],
+                level=lvl,
+                round_no=0,
+                wallet=int(st.session_state.wallet),
+                health=int(st.session_state.health),
+                happiness=int(st.session_state.happiness),
+                credit_score=int(st.session_state.loan.creditScore),
+                event_json={"phase": st.session_state.gamePhase},
+                outcome=("level_complete" if st.session_state.gamePhase == "level-complete" else "game_complete"),
+                gained_xp=50,
+                elapsed_ms=elapsed_ms,
+            )
+
         st.session_state[key] = True
+        _refresh_global_xp()
         st.success("Saved +50 XP for completing this loan")
     except Exception as e:
         st.error(f"Could not save completion XP: {e}")
@@ -346,6 +378,8 @@ def init_state():
             missedPayments=0,
             creditScore=random.randint(200, 600),
         )
+        if "dd_start_ts" not in st.session_state:
+            st.session_state.dd_start_ts = time.time()
 
 # Fortnight helper (every 2 weeks)
 def current_fortnight() -> int:
@@ -420,6 +454,7 @@ def gen_random_event() -> Optional[RandomEvent]:
 # Game actions
 # ===============================
 def start_loan():
+    st.session_state.dd_start_ts = time.time()   # start elapsed timer
     st.session_state.gamePhase = "repaying"
     if DISBURSE_LOAN_TO_WALLET:
         st.session_state.wallet += st.session_state.loan.principal
@@ -955,6 +990,7 @@ def reset_game():
         if k not in {"user", "current_page", "xp", "streak", "current_game", "temp_user"}:
             del st.session_state[k]
     init_state()
+    st.session_state.dd_start_ts = time.time()   # fresh timer after reset
     st.rerun()
 
 def hospital_screen():
@@ -984,8 +1020,8 @@ def level_complete_screen():
             creditScore=st.session_state.loan.creditScore,
         )
         st.session_state.monthlyIncome = lvl.startingIncome
+        st.session_state.dd_start_ts = time.time()   # reset timer for new level
         st.session_state.gamePhase = "setup"
-    #  use scoped button
     st.buttondd("➡️ Start next level", on_click=_go_next, key="btn_next_level", variant="success")
 
 def completed_screen():

phase/Student_view/games/profitpuzzle.py

@@ -1,12 +1,19 @@
-from utils import db as dbapi
+import os, time
 import streamlit as st
+from utils import api as backend         # HTTP to backend Space
+from utils import db as dbapi            # direct DB path (only if DISABLE_DB=0)
+
+DISABLE_DB = os.getenv("DISABLE_DB", "1") == "1"
 
 def _refresh_global_xp():
     user = st.session_state.get("user")
     if not user:
         return
     try:
-        stats = dbapi.user_xp_and_level(user["user_id"])
+        if DISABLE_DB:
+            stats = backend.user_stats(user["user_id"])
+        else:
+            stats = dbapi.user_xp_and_level(user["user_id"])
         st.session_state.xp = stats.get("xp", st.session_state.get("xp", 0))
         st.session_state.streak = stats.get("streak", st.session_state.get("streak", 0))
     except Exception as e:
@@ -279,6 +286,7 @@ def reset_game():
     st.session_state.show_solution = False
     st.session_state.score = 0
     st.session_state.completed_scenarios = []
+    st.session_state.pp_start_ts = time.time()
     st.rerun()
 
 
@@ -288,6 +296,9 @@ def show_profit_puzzle():
     # Load CSS styling
     load_css()
     
+    if "pp_start_ts" not in st.session_state:
+        st.session_state.pp_start_ts = time.time()
+
     st.markdown("""
     <div class="game-header">
         <h1>🎯 Profit Puzzle Challenge!</h1>
@@ -401,28 +412,58 @@ def show_profit_puzzle():
         # Persist to TiDB if logged in
         user = st.session_state.get("user")
         if user:
+            elapsed_ms = int((time.time() - st.session_state.get("pp_start_ts", time.time())) * 1000)
+
             try:
-                dbapi.record_profit_puzzle_result(
-                    user_id=user["user_id"],
-                    scenario_id=scenario.get("id") or f"scenario_{st.session_state.current_scenario}",
-                    title=scenario.get("title", f"Scenario {st.session_state.current_scenario+1}"),
-                    units=units, price=price, cost=cost,
-                    user_answer=user_val, actual_profit=float(actual_profit),
-                    is_correct=bool(correct), gained_xp=int(reward)
-                )
+                if DISABLE_DB:
+                    # Route to backend Space
+                    backend.record_profit_puzzler_play(
+                        user_id=user["user_id"],
+                        puzzles_solved=1 if correct else 0,
+                        mistakes=0 if correct else 1,
+                        elapsed_ms=elapsed_ms,
+                        gained_xp=reward  # keep UI and server in sync
+                    )
+                else:
+                    # Direct DB path if you keep it
+                    if hasattr(dbapi, "record_profit_puzzler_play"):
+                        dbapi.record_profit_puzzler_play(
+                            user_id=user["user_id"],
+                            puzzles_solved=1 if correct else 0,
+                            mistakes=0 if correct else 1,
+                            elapsed_ms=elapsed_ms,
+                            gained_xp=reward
+                        )
+                    else:
+                        # Fallback to your existing detailed writer
+                        dbapi.record_profit_puzzle_result(
+                            user_id=user["user_id"],
+                            scenario_id=scenario.get("id") or f"scenario_{st.session_state.current_scenario}",
+                            title=scenario.get("title", f"Scenario {st.session_state.current_scenario+1}"),
+                            units=int(scenario["variables"]["units"]),
+                            price=int(scenario["variables"]["sellingPrice"]),
+                            cost=int(scenario["variables"]["costPerUnit"]),
+                            user_answer=float(st.session_state.user_answer),
+                            actual_profit=float(actual_profit),
+                            is_correct=bool(correct),
+                            gained_xp=int(reward)
+                        )
+
                 _refresh_global_xp()
             except Exception as e:
-                st.warning(f"Could not save result: {e}")
+                st.warning(f"Save failed: {e}")
         else:
             st.info("Login to earn and save XP.")
 
         st.session_state.show_solution = True
 
     def next_scenario():
-        if st.session_state.current_scenario < len(scenarios) - 1:
+        if st.session_state.get("current_scenario", 0) < len(st.session_state.get("profit_scenarios", [])) - 1:
             st.session_state.current_scenario += 1
             st.session_state.user_answer = ""
             st.session_state.show_solution = False
+            st.session_state.pp_start_ts = time.time()
+        st.rerun()
 
     def reset_game():
         st.session_state.current_scenario = 0

utils/api.py

@@ -409,4 +409,41 @@ def record_money_match_play(user_id: int, target: int, total: int,
     }
     return _try_candidates("POST", [
         ("/games/money_match/record", {"json": payload}),
-    ])
+    ])
+
+def record_budget_builder_play(user_id: int, weekly_allowance: int, budget_score: int,
+                               elapsed_ms: int, allocations: list[dict], gained_xp: int | None):
+    payload = {
+        "user_id": user_id,
+        "weekly_allowance": weekly_allowance,
+        "budget_score": budget_score,
+        "elapsed_ms": elapsed_ms,
+        "allocations": allocations,
+        "gained_xp": gained_xp,
+    }
+    return _try_candidates("POST", [
+        ("/games/budget_builder/record", {"json": payload}),
+    ])
+
+
+def record_debt_dilemma_play(user_id: int, loans_cleared: int,
+                             mistakes: int, elapsed_ms: int, gained_xp: int):
+    payload = {
+        "user_id": user_id,
+        "loans_cleared": loans_cleared,
+        "mistakes": mistakes,
+        "elapsed_ms": elapsed_ms,
+        "gained_xp": gained_xp,
+    }
+    return _try_candidates("POST", [
+        ("/games/debt_dilemma/record", {"json": payload}),
+        ("/api/games/debt_dilemma/record", {"json": payload}),
+        ("/api/v1/games/debt_dilemma/record", {"json": payload}),
+    ])
+
+
+def record_profit_puzzler_play(user_id: int, puzzles_solved: int, mistakes: int, elapsed_ms: int, gained_xp: int | None = None):
+    payload = {"user_id": user_id, "puzzles_solved": puzzles_solved, "mistakes": mistakes, "elapsed_ms": elapsed_ms}
+    if gained_xp is not None:
+        payload["gained_xp"] = gained_xp
+    return _try_candidates("POST", [("/games/profit_puzzler/record", {"json": payload})])