added exact details of Reward Point

app.py

@@ -7,7 +7,7 @@ from google_auth_oauthlib.flow import InstalledAppFlow
 import json
 import gradio as gr
 import time
-from datetime import datetime, timedelta
+from datetime import datetime
 from pytz import timezone
 import threading
 from dotenv import load_dotenv
@@ -117,6 +117,204 @@ def get_studentwise_data(spreadsheet):
         print(f"❌ Error loading Studentwise Reward Points: {str(e)}")
         return None
 
+# NEW FUNCTION: Load and cache reward points activity data
+def load_reward_points_data():
+    """Load and cache reward points activity data"""
+    try:
+        # Get the reward points sheet ID from environment
+        REWARD_POINTS_SHEET_ID = os.getenv('REWARD_POINTS_SHEET_ID')
+        
+        if not REWARD_POINTS_SHEET_ID:
+            print("⚠️ REWARD_POINTS_SHEET_ID not found in environment variables")
+            return None
+        
+        client = authorize()
+        spreadsheet = client.open_by_key(REWARD_POINTS_SHEET_ID)
+        worksheet = spreadsheet.get_worksheet_by_id(1113414351)  # Activity Sheet GID
+        all_values = worksheet.get_all_values()
+        
+        if not all_values or len(all_values) < 2:
+            print("⚠️ Reward Points sheet doesn't have enough data")
+            return None
+        
+        # First row is header
+        headers = all_values[0]
+        df = pd.DataFrame(all_values[1:], columns=headers)
+        
+        if df.empty:
+            print("⚠️ Reward Points sheet is empty")
+            return None
+        
+        print(f"✅ Loaded {len(df)} rows from Reward Points Entry sheet")
+        return df
+        
+    except Exception as e:
+        print(f"❌ Error loading Reward Points data: {str(e)}")
+        return None
+
+# MODIFIED FUNCTION: Get activity details from cached data
+def get_activity_details(roll_no, reward_points_df):
+    """Get activity details for a specific roll number from cached reward points data in breakdown format"""
+    try:
+        if reward_points_df is None or reward_points_df.empty:
+            return ""
+        
+        # Normalize roll number for search
+        roll_no_search = roll_no.strip().upper()
+        
+        # Try to find the roll number column
+        roll_col = None
+        for col in reward_points_df.columns:
+            if 'roll' in col.lower() and 'no' in col.lower():
+                roll_col = col
+                break
+        
+        if not roll_col:
+            # Use first column as roll number column
+            roll_col = reward_points_df.columns[0]
+        
+        # Create a copy to avoid modifying the original cached data
+        df = reward_points_df.copy()
+        
+        # Normalize the roll number column
+        df[roll_col] = df[roll_col].astype(str).str.strip().str.upper()
+        
+        # Filter rows by roll number
+        student_rows = df[df[roll_col] == roll_no_search]
+        
+        if student_rows.empty:
+            # Try partial matching
+            partial_matches = df[df[roll_col].str.contains(roll_no_search, na=False)]
+            if not partial_matches.empty:
+                student_rows = partial_matches
+            else:
+                return ""
+        
+        if student_rows.empty:
+            return ""
+        
+        # Get student info from first record
+        first_record = student_rows.iloc[0]
+        student_name = first_record.get('NAME OF THE STUDENT', 'N/A')
+        student_year = first_record.get('YEAR OF STUDY', 'N/A')
+        student_dept = first_record.get('DEPARTMENT', 'N/A')
+        
+        # Calculate activity summary by type
+        activity_summary = {}
+        activity_count = {}
+        total_points = 0
+        
+        for _, row in student_rows.iterrows():
+            activity_type = str(row.get('Activity Type', 'N/A'))
+            reward_points = str(row.get('Reward Points', '0'))
+            
+            # Convert points to float
+            try:
+                points_val = float(reward_points.replace(',', '')) if reward_points else 0
+                total_points += points_val
+            except:
+                points_val = 0
+            
+            # Track activity summary
+            if activity_type in activity_summary:
+                activity_summary[activity_type] += points_val
+                activity_count[activity_type] += 1
+            else:
+                activity_summary[activity_type] = points_val
+                activity_count[activity_type] = 1
+        
+        # Format output in breakdown style
+        output = []
+        # Define all possible activity categories in order
+        activity_categories = [
+            "INITIAL POINTS / CARRY-OVER",
+            "TECHNICAL EVENTS", 
+            "SKILLS",
+            "ASSIGNMENTS",
+            "INTERVIEW",
+            "TECHNICAL SOCIETY ACTIVITIES",
+            "P SKILL",
+            "TAC",
+            "SPECIAL LAB INITIATIVES", 
+            "EXTRA-CURRICULAR ACTIVITIES",
+            "STUDENT INITIATIVES",
+            "EXTERNAL EVENTS",
+            "EXTERNAL TECHNICAL EVENTS"
+        ]
+        
+        # Map activity types to standard categories (case-insensitive matching)
+        category_mapping = {}
+        for activity_type in activity_summary.keys():
+            activity_upper = activity_type.upper()
+            matched_category = None
+            
+            # Try exact matching first
+            for category in activity_categories:
+                if category.upper() in activity_upper or activity_upper in category.upper():
+                    matched_category = category
+                    break
+            
+            # If no exact match, use the original activity type
+            if not matched_category:
+                matched_category = activity_type
+            
+            category_mapping[activity_type] = matched_category
+        
+        # Group activities by mapped categories
+        final_summary = {}
+        final_count = {}
+        
+        for activity_type, points in activity_summary.items():
+            category = category_mapping[activity_type]
+            if category in final_summary:
+                final_summary[category] += points
+                final_count[category] += activity_count[activity_type]
+            else:
+                final_summary[category] = points
+                final_count[category] = activity_count[activity_type]
+        
+        # Display all categories (including zeros)
+        for category in activity_categories:
+            count = final_count.get(category, 0)
+            points = final_summary.get(category, 0.0)
+            
+        
+        # Add any categories not in the standard list
+        for category, points in final_summary.items():
+            if category not in activity_categories:
+                count = final_count.get(category, 0)
+        
+        
+        # Add detailed activity list if needed
+        if len(student_rows) <= 20:  # Only show detailed list for reasonable number of activities
+            output.append("")
+            output.append("=" * 80)
+            output.append("📋 DETAILED ACTIVITY LIST")
+            output.append("=" * 80)
+            
+            for idx, (_, row) in enumerate(student_rows.iterrows(), 1):
+                activity_type = str(row.get('Activity Type', 'N/A'))
+                activity_name = str(row.get('Activity Name', 'N/A'))
+                reward_points = str(row.get('Reward Points', '0'))
+                
+                try:
+                    points_val = float(reward_points.replace(',', '')) if reward_points else 0
+                except:
+                    points_val = 0
+                
+                # Truncate long names for display
+                display_name = activity_name[:50] + "..." if len(activity_name) > 63 else activity_name
+                output.append(f"{idx:2d}. {activity_type}: {display_name} - {points_val:.2f} pts")
+        
+        
+        output.append("=" * 80)
+        
+        return "\n".join(output)
+    
+    except Exception as e:
+        print(f"❌ Error fetching activity details: {str(e)}")
+        return ""
+
 # Function to get details sheet information
 def get_details_info(spreadsheet):
     try:
@@ -206,7 +404,6 @@ STUDENTWISE_SHEET_ID = os.getenv('STUDENTWISE_SHEET_ID')  # Studentwise Reward P
 if not MAIN_SHEET_ID:
     raise ValueError("GOOGLE_SHEET_ID environment variable is required")
 
-
 # Open both spreadsheets
 main_spreadsheet = client.open_by_key(MAIN_SHEET_ID)
 studentwise_spreadsheet = client.open_by_key(STUDENTWISE_SHEET_ID)
@@ -236,26 +433,28 @@ sheet_configs = [
     {"gid": 400900059, "name": "Sheet_20"}
 ]
 
-# 🕒 GLOBAL DATA CACHE WITH 12-HOUR AUTO-REFRESH
+# 🕒 GLOBAL DATA CACHE WITH 12-HOUR AUTO-REFRESH (NOW INCLUDES REWARD POINTS DATA)
 data_cache = {
     "combined_df": None,
     "studentwise_data": None,
     "details_info": None,
+    "reward_points_df": None,  # NEW: Cache for reward points data
     "last_update": None,
     "cache_duration_hours": 12,  # 12 hours cache
     "is_loading": False
 }
 
 def load_all_data():
-    """Load and cache all data from Google Sheets"""
+    """Load and cache all data from Google Sheets (including reward points data)"""
     global data_cache
     
     if data_cache["is_loading"]:
         print("⏳ Data loading already in progress...")
-        return data_cache["combined_df"], data_cache["studentwise_data"], data_cache["details_info"]
+        return (data_cache["combined_df"], data_cache["studentwise_data"], 
+                data_cache["details_info"], data_cache["reward_points_df"])
     
     data_cache["is_loading"] = True
-    print(f"🔄 Loading fresh data from {len(sheet_configs)} Google Sheets...")
+    print(f"🔄 Loading fresh data from {len(sheet_configs)} Google Sheets + Reward Points sheet...")
     start_time = time.time()
     
     try:
@@ -315,23 +514,28 @@ def load_all_data():
         # Load details info from main spreadsheet
         details_info = get_details_info(main_spreadsheet)
         
+        # NEW: Load reward points activity data
+        reward_points_df = load_reward_points_data()
+        
         # Update cache
         data_cache["combined_df"] = combined_df
         data_cache["studentwise_data"] = studentwise_data
         data_cache["details_info"] = details_info
+        data_cache["reward_points_df"] = reward_points_df  # NEW: Cache reward points data
         data_cache["last_update"] = datetime.now()
         
         load_time = time.time() - start_time
         print(f"⏱️ Data loaded and cached in {load_time:.2f} seconds")
         print(f"📊 Next auto-refresh in {data_cache['cache_duration_hours']} hours")
         
-        return combined_df, studentwise_data, details_info
+        return combined_df, studentwise_data, details_info, reward_points_df
         
     except Exception as e:
         print(f"❌ Error loading data: {str(e)}")
         return (data_cache.get("combined_df", pd.DataFrame()), 
                 data_cache.get("studentwise_data", None),
-                data_cache.get("details_info", None))
+                data_cache.get("details_info", None),
+                data_cache.get("reward_points_df", None))
     
     finally:
         data_cache["is_loading"] = False
@@ -350,7 +554,8 @@ def get_cached_data():
     else:
         cache_age_hours = (now - data_cache["last_update"]).total_seconds() / 3600
         print(f"🚀 Using cached data (age: {cache_age_hours:.1f} hours)")
-        return data_cache["combined_df"], data_cache["studentwise_data"], data_cache["details_info"]
+        return (data_cache["combined_df"], data_cache["studentwise_data"], 
+                data_cache["details_info"], data_cache["reward_points_df"])
 
 def auto_refresh_worker():
     """Background worker to auto-refresh data every 12 hours"""
@@ -385,7 +590,6 @@ def get_detailed_student_points(roll_no, studentwise_data):
     
     output = []
     output.append("\n")
-    output.append("=" * 80)
     output.append("🏆 REWARD POINTS BREAKDOWN")
     output.append("=" * 80)
     
@@ -457,7 +661,7 @@ def search_student(roll_no):
     roll_no = roll_no.strip().upper()
     
     # Get cached data (fast response, auto-refreshes every 12 hours)
-    combined_df, studentwise_data, details_info = get_cached_data()
+    combined_df, studentwise_data, details_info, reward_points_df = get_cached_data()
     
     if combined_df.empty:
         return "❌ No data available from Google Sheets"
@@ -481,12 +685,11 @@ def search_student(roll_no):
     student_name = str(record.get('STUDENT NAME', 'Unknown')).strip()
     student_year = str(record.get('YEAR', '')).strip()
 
-    # Time Zone conversion
+    # Time zone Conversion
     ist = timezone("Asia/Kolkata")
     now_ist = datetime.now(ist).strftime("%Y-%m-%d %H:%M:%S")
-    
     # Log to see which roll number and student name is searched by user
-    print(f"Roll No Searched: {roll_no} | Student Name: {student_name} | Time: {now_ist}")
+    print(f"Roll No Searched: {roll_no} | Student Name: {student_name} | Time (IST): {now_ist}")
     
     # Format output - Simplified version
     output = []
@@ -544,11 +747,18 @@ def search_student(roll_no):
                     output.append("   Keep up the great work! 🌟")
                     output.append("   Refer Reward points Breakdown for more details")
     
+    
+    # MODIFIED: Add individual activity details from cached reward points data
+    activity_details = get_activity_details(roll_no, reward_points_df)
+    if activity_details:
+        output.append(activity_details)
+    
     # Add detailed points breakdown from studentwise data
     detailed_points = get_detailed_student_points(roll_no, studentwise_data)
     if detailed_points:
         output.append(detailed_points)
     
+    
     # Add last updated info
     if details_info and 'last_updated' in details_info:
         output.append("\n" + "-" * 60)
@@ -573,7 +783,7 @@ def search_student(roll_no):
 
 # Function to get system information
 def get_system_info():
-    combined_df, studentwise_data, details_info = get_cached_data()
+    combined_df, studentwise_data, details_info, reward_points_df = get_cached_data()
     
     if not details_info:
         return "❌ No system information available"
@@ -611,6 +821,14 @@ def get_system_info():
         output.append("-" * 40)
         output.append(details_info['last_updated'])
     
+    # NEW: Add reward points data info
+    if reward_points_df is not None:
+        output.append(f"\nREWARD POINTS DATA:")
+        output.append("-" * 40)
+        output.append(f"Total activity records: {len(reward_points_df)}")
+        unique_students = reward_points_df.iloc[:, 0].nunique() if not reward_points_df.empty else 0
+        output.append(f"Students with activities: {unique_students}")
+    
     # Cache info
     if data_cache["last_update"]:
         cache_age = datetime.now() - data_cache["last_update"]
@@ -701,6 +919,7 @@ with gr.Blocks(title="Student Reward Points Check", theme=gr.themes.Soft()) as a
                 elem_id="footer"
             )
 
+
 # Launch the app
 if __name__ == "__main__":
     print("🚀 Launching Gradio interface...")