Merge pull request #28 from Yuval-Roth/fixingGraphs

READY

Author: Yuval-Roth

manager/src/app.py

@@ -7,6 +7,7 @@
 from .managers.game import *
 from .managers.operators import *
 from .managers.session_data import *
+from .managers.feedback import *
 from .managers.logger import Logger
 from .ENUMS import *
 import json
@@ -70,6 +71,13 @@ def get_parts():
                 online_participants.append(part)
         print(f"online_participants: {online_participants}")
         return jsonify(online_participants)
+    elif all_participants:
+        all = []
+        for part in all_participants:
+            part = json.loads(part)
+            part['id'] = str(part['pid']).zfill(3)
+            all.append(part)
+        return jsonify(all)
     return jsonify(all_participants)
 
 
@@ -82,7 +90,7 @@ def lobbies_menu():
     if lobbies:
         lobbies = lobbies.lobbies
     else:
-        lobbies = LOBBIES
+        lobbies = []
     return render_template('lobbies.html', lobbies=lobbies)
 
 
@@ -430,6 +438,7 @@ def single_session_data():
     game_type    = request.args.get('game_type', '')
     participants = request.args.get('participants', '')
     duration     = request.args.get('duration', '')
+    tolerance   = request.args.get('tolerance', '')
 
     # ── metrics ──
     heart    = get_heartrate(sid)
@@ -450,7 +459,9 @@ def single_session_data():
         "gameType"    : game_type,
         "participants": [p.strip() for p in participants.split(',') if p],
         "sessionId"   : sid,
-        "duration"    : duration
+        "duration"    : duration,
+        "tolerance"   : tolerance
+
     }
     data = {
         "heart"          : heart,
@@ -480,6 +491,47 @@ def get_all_sessions_route():
         return jsonify({"status": "error",
                         "message": "Internal server error"}), 500
 
+
+
+@app.route('/session_data/feedback', methods=['GET'])
+def session_feedback():
+    # 1) Get session_id from query string
+    sid = request.args.get('session_id')
+    if not sid:
+        return jsonify({ "success": False, "message": "Missing session_id" }), 400
+
+    # 2) Call internal helper to fetch feedback
+    try:
+        feedback_list = get_feedback(sid)
+    except Exception as e:
+        Logger.log_error(f"session_feedback – Exception: {e}")
+        return jsonify({ "success": False, "message": "Internal server error" }), 500
+
+    return jsonify({
+        "success": True,
+        "payload": feedback_list
+    })
+
+
+@app.route('/session_data/experiment_feedback', methods=['GET'])
+def experiment_feedback():
+    exp_id = request.args.get('exp_id')
+    if not exp_id:
+        return jsonify({"success": False, "message": "Missing exp_id"}), 400
+
+    try:
+        feedback_list = get_experiment_feedback(exp_id)
+    except Exception as e:
+        Logger.log_error(f"experiment_feedback – Exception: {e}")
+        return jsonify({"success": False, "message": "Internal server error"}), 500
+
+    return jsonify({
+        "success": True,
+        "payload": feedback_list
+    })
+
+
+
 @app.route('/experiment_questions', methods=['GET'])
 def get_experiment_questions_route():
     if RUNNING_LOCAL:

manager/src/managers/feedback.py

@@ -0,0 +1,98 @@
+# managers/feedback.py
+
+from typing import List
+from flask import session
+from . import post_auth, server_response, URL
+from .logger import Logger
+import json
+
+
+def get_feedback(sid: str) -> List[dict]:
+    """
+    Fetches feedback for a given session ID by calling the internal
+    /data/session/select/feedback endpoint, then returns a list of
+    { "question": ..., "answer": ... } dictionaries.
+    """
+    feedback_list: List[dict] = []
+    try:
+        # Build request body
+        body = {"sessionId": sid}
+
+        # Perform authenticated POST to the internal endpoint
+        token = session.get('token', '')
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json"
+        }
+        response = post_auth(f"{URL}/data/session/select/feedback", json=body, headers=headers)
+
+        # Only proceed if we got a 200 or 201
+        if response.status_code in (200, 201):
+            ser_res = server_response(response)
+            if ser_res.get_success():
+                raw_payload = ser_res.get_payload() or []
+                for item in raw_payload:
+                    try:
+                        # If payload items are JSON‐strings, parse them
+                        feedback_list.append(json.loads(item))
+                    except Exception:
+                        # If already a dict, just append
+                        if isinstance(item, dict):
+                            feedback_list.append(item)
+                return feedback_list
+
+            Logger.log_error(f"get_feedback – API returned error: {ser_res.get_message()}")
+            return []
+
+        Logger.log_error(f"get_feedback – HTTP {response.status_code}")
+        return []
+
+    except Exception as e:
+        Logger.log_error(f"get_feedback – Exception: {e}")
+        return []
+
+
+def get_experiment_feedback(exp_id: str) -> List[dict]:
+    """
+    Fetch all feedback for experiment (= lobby) with ID = exp_id.
+    Calls internal /data/experiment/select/feedback endpoint.
+    Returns a list of dictionaries like { "pid": ..., "question": ..., "answer": ... }.
+    """
+    feedback_list: List[dict] = []
+    try:
+        # Build request body
+        body = {"expId": exp_id}
+
+        # Perform authenticated POST to the internal endpoint
+        token = session.get('token', '')
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json"
+        }
+        response = post_auth(f"{URL}/data/experiment/select/feedback", json=body, headers=headers)
+
+        # Check HTTP status
+        if response.status_code in (200, 201):
+            ser_res = server_response(response)
+            if ser_res.get_success():
+                raw_payload = ser_res.get_payload() or []
+                for item in raw_payload:
+                    try:
+                        # If payload items are JSON‐strings, parse them
+                        feedback_list.append(json.loads(item))
+                    except Exception:
+                        # If already a dict, just append
+                        if isinstance(item, dict):
+                            feedback_list.append(item)
+                return feedback_list
+
+            Logger.log_error(f"get_experiment_feedback – API error: {ser_res.get_message()}")
+            return []
+        else:
+            Logger.log_error(f"get_experiment_feedback – HTTP {response.status_code}")
+            return []
+
+    except Exception as e:
+        Logger.log_error(f"get_experiment_feedback – Exception: {e}")
+        return []
+

manager/src/managers/session_data.py

@@ -205,33 +205,41 @@ def get_swipe_game_frequency(session_id: str):
         except (ValueError, TypeError) as e:
             Logger.log_error(f"Invalid FREQUENCY data: {ev['data']}  error={e}")
 
-    # angle data
-
+    # --- ANGLE DATA: drop any value == 600, then convert degrees → sin(radians) so y ∈ [-1,1] ---
     for ev in angle_events:
         try:
+            raw_value = float(ev["data"])
+            if raw_value == 600:
+                # skip any outlier or placeholder of 600
+                continue
+
             timestamp_sec = ev["timestamp"] / 1000.0
-            value = float(ev["data"])
+            # convert degrees → radians, then take sine for unit-circle range
+            rad    = math.radians(raw_value)
+            unit_y = math.sin(rad)
+
             angle_data[ev["actor"]]["timestamps"].append(f"{timestamp_sec:.3f}")
-            angle_data[ev["actor"]]["values"].append(value)
+            angle_data[ev["actor"]]["values"].append(unit_y)
         except (ValueError, TypeError) as e:
             Logger.log_error(f"Invalid ANGLE data: {ev['data']}  error={e}")
 
-    # Sort data for each actor by timestamp
+    # --- SORT FREQUENCY DATA BY TIMESTAMP ---
     for actor, data in frequency_data.items():
         combined = list(zip(map(float, data["timestamps"]), data["values"]))
         combined.sort(key=lambda x: x[0])
         data["timestamps"] = [f"{t:.3f}" for t, _ in combined]
-        data["values"] = [v for _, v in combined]
+        data["values"]     = [v for _, v in combined]
 
-    # Sort angle data for each actor by timestamp
+    # --- SORT ANGLE DATA BY TIMESTAMP ---
     for actor, data in angle_data.items():
         combined = list(zip(map(float, data["timestamps"]), data["values"]))
         combined.sort(key=lambda x: x[0])
         data["timestamps"] = [f"{t:.3f}" for t, _ in combined]
-        data["values"] = [v for _, v in combined]
+        data["values"]     = [v for _, v in combined]
 
+    # --- SYNC INTERVALS ---
     sync_start_times = sorted(ev["timestamp"] / 1000.0 for ev in sync_start_events)
-    sync_end_times = sorted(ev["timestamp"] / 1000.0 for ev in sync_end_events)
+    sync_end_times   = sorted(ev["timestamp"] / 1000.0 for ev in sync_end_events)
 
     if len(sync_start_times) != len(sync_end_times):
         Logger.log_error(f"Session {session_id}: Mismatched SYNC_START_TIME and SYNC_END_TIME events")
@@ -241,6 +249,7 @@ def get_swipe_game_frequency(session_id: str):
     return dict(frequency_data), dict(angle_data), sync_intervals
 
 
+
 def get_lobbies_data() -> list[dict]:
     try:
         res = server_response(

manager/src/static/session_data.css

@@ -104,3 +104,23 @@
 .session-container::-webkit-scrollbar-track {
     background-color: #f1f1f1;
 }
+
+.reset-btn {
+  position: absolute;
+  top: 12px;
+  right: 12px;
+  z-index: 10;
+  font-size: 12px;
+  padding: 4px 8px;
+  background-color: #4CAF50;
+  color: white;
+  border: 1px solid #45a049;
+  border-radius: 4px;
+  cursor: pointer;
+  opacity: 1;
+  transition: opacity 0.2s;
+}
+
+.reset-btn:hover {
+  opacity: 0.8;
+}