Fix: Handle empty dataframes and add validation for all inputs

app.py

@@ -154,12 +154,24 @@ def add_task(task_type, complexity, deadline):
 def update_progress(task_id, user_id, progress, notes):
     """Update task progress"""
     try:
-        if task_id <= 0 or user_id <= 0:
-            return "❌ Please enter valid Task ID and User ID"
+        if task_id is None or task_id <= 0:
+            return "❌ Please enter a valid Task ID"
+        if user_id is None or user_id <= 0:
+            return "❌ Please enter a valid User ID"
         if not (0 <= progress <= 100):
             return "❌ Progress must be between 0 and 100"
+        
+        # Validate task exists
+        task_df = tm.engine.tasks[tm.engine.tasks['task_id'] == int(task_id)]
+        if len(task_df) == 0:
+            return f"❌ Task ID {int(task_id)} not found!"
+        
+        # Validate user exists
+        user_df = tm.engine.users[tm.engine.users['user_id'] == int(user_id)]
+        if len(user_df) == 0:
+            return f"❌ User ID {int(user_id)} not found!"
             
-        tm.update_progress(int(task_id), int(user_id), int(progress), notes.strip())
+        tm.update_progress(int(task_id), int(user_id), int(progress), notes.strip() if notes else "")
         return f"✅ Progress updated: Task {int(task_id)} → {int(progress)}%"
         
     except Exception as e:
@@ -168,23 +180,40 @@ def update_progress(task_id, user_id, progress, notes):
 def complete_task(task_id, user_id, time_taken, quality):
     """Complete a task - THIS IS HOW AI LEARNS"""
     try:
-        if task_id <= 0 or user_id <= 0:
-            return "❌ Please enter valid Task ID and User ID"
+        if task_id is None or task_id <= 0:
+            return "❌ Please enter a valid Task ID"
+        if user_id is None or user_id <= 0:
+            return "❌ Please enter a valid User ID"
         if not (1 <= quality <= 5):
             return "❌ Quality must be between 1 and 5"
-        if time_taken <= 0:
+        if time_taken is None or time_taken <= 0:
             return "❌ Time taken must be positive"
+        
+        # Validate task exists
+        task_df = tm.engine.tasks[tm.engine.tasks['task_id'] == int(task_id)]
+        if len(task_df) == 0:
+            return f"❌ Task ID {int(task_id)} not found! Check the Dashboard for valid Task IDs."
+        
+        # Validate user exists
+        user_df = tm.engine.users[tm.engine.users['user_id'] == int(user_id)]
+        if len(user_df) == 0:
+            return f"❌ User ID {int(user_id)} not found! Check the Dashboard for valid User IDs."
             
         tm.enter_result(int(task_id), int(user_id), float(time_taken), int(quality))
         
-        return f"""✅ Task {int(task_id)} completed!
+        task_name = task_df['type'].iloc[0]
+        user_name = user_df['name'].iloc[0]
+        
+        return f"""✅ Task completed successfully!
 
-**Result recorded:**
+**Details:**
+- Task: {task_name} (ID: {int(task_id)})
+- Completed by: {user_name} (ID: {int(user_id)})
 - Time taken: {time_taken}h
 - Quality: {int(quality)}/5
 
 🧠 **AI is learning from this result!**
-Retrain the AI in the 'AI Training' tab to improve future assignments."""
+Retrain the AI in the 'Train AI' tab to improve future assignments."""
         
     except Exception as e:
         return f"Error: {str(e)}"

assignment_engine.py

@@ -41,9 +41,17 @@ class TaskAssignmentEngine:
         if len(self.results) == 0:
             print("⚠️  No results data - will use random assignment")
             return None, None
+        
+        if len(self.tasks) == 0 or len(self.users) == 0:
+            print("⚠️  No tasks or users - cannot prepare training data")
+            return None, None
             
         # Merge results with task and user data
-        training_data = self.results.merge(self.tasks, on='task_id').merge(self.users, on='user_id')
+        training_data = self.results.merge(self.tasks, on='task_id', how='inner').merge(self.users, on='user_id', how='inner')
+        
+        if len(training_data) == 0:
+            print("⚠️  No valid training data after merge")
+            return None, None
         
         # Create features: user_id, complexity, deadline
         X = training_data[['user_id', 'complexity', 'deadline']].values
@@ -59,7 +67,7 @@ class TaskAssignmentEngine:
         y = (quality_score * 0.7 + efficiency * 0.3)  # 70% quality, 30% efficiency
         
         print(f"✅ Prepared training data: {len(X)} samples")
-        return X, y
+        return X, y.values
     
     def train_model(self):
         """Train the AI model"""
@@ -97,7 +105,18 @@ class TaskAssignmentEngine:
         
     def assign_task(self, task_id):
         """Assign a task to the best user"""
-        task_row = self.tasks[self.tasks['task_id'] == task_id].iloc[0]
+        # Check if users exist
+        if len(self.users) == 0:
+            print("❌ No users available")
+            return None, None
+            
+        # Check if task exists
+        task_df = self.tasks[self.tasks['task_id'] == task_id]
+        if len(task_df) == 0:
+            print(f"❌ Task {task_id} not found")
+            return None, None
+            
+        task_row = task_df.iloc[0]
         
         best_user = None
         best_score = -1
@@ -143,7 +162,11 @@ class TaskAssignmentEngine:
     def start_task_tracking(self, task_id, user_id, user_name):
         """Start tracking a task"""
         task_key = f"{task_id}_{user_id}"
-        task_info = self.tasks[self.tasks['task_id'] == task_id].iloc[0]
+        task_df = self.tasks[self.tasks['task_id'] == task_id]
+        if len(task_df) == 0:
+            print(f"❌ Task {task_id} not found for tracking")
+            return
+        task_info = task_df.iloc[0]
         
         self.progress_data[task_key] = {
             'task_id': task_id,
@@ -187,6 +210,17 @@ class TaskAssignmentEngine:
             
     def add_result(self, task_id, user_id, time_taken, quality):
         """Add task completion result"""
+        # Validate task and user exist
+        task_df = self.tasks[self.tasks['task_id'] == task_id]
+        user_df = self.users[self.users['user_id'] == user_id]
+        
+        if len(task_df) == 0:
+            print(f"❌ Task {task_id} not found")
+            return False
+        if len(user_df) == 0:
+            print(f"❌ User {user_id} not found")
+            return False
+            
         # Update progress tracking with completion
         task_key = f"{task_id}_{user_id}"
         completion_time = datetime.now()
@@ -217,8 +251,8 @@ class TaskAssignmentEngine:
         self.results.to_csv(self.results_file, index=False)
         
         # Get names for display
-        task_name = self.tasks[self.tasks['task_id'] == task_id]['type'].iloc[0]
-        user_name = self.users[self.users['user_id'] == user_id]['name'].iloc[0]
+        task_name = task_df['type'].iloc[0]
+        user_name = user_df['name'].iloc[0]
         
         print(f"✅ Task Completed: {user_name} → {task_name} in {time_taken}h with quality {quality}/5")
         

task_manager.py

@@ -54,15 +54,22 @@ class TaskManager:
         
     def add_user(self, name):
         """Add new user"""
-        new_id = self.engine.users['user_id'].max() + 1
+        if len(self.engine.users) == 0:
+            new_id = 1
+        else:
+            new_id = int(self.engine.users['user_id'].max()) + 1
         new_user = pd.DataFrame({'user_id': [new_id], 'name': [name]})
         self.engine.users = pd.concat([self.engine.users, new_user], ignore_index=True)
         self.engine.users.to_csv("users.csv", index=False)
         print(f"✅ Added user: {name} (ID: {new_id})")
+        return new_id
         
     def add_task(self, task_type, complexity, deadline):
         """Add new task"""
-        new_id = self.engine.tasks['task_id'].max() + 1
+        if len(self.engine.tasks) == 0:
+            new_id = 1
+        else:
+            new_id = int(self.engine.tasks['task_id'].max()) + 1
         new_task = pd.DataFrame({
             'task_id': [new_id], 
             'type': [task_type], 
@@ -72,6 +79,7 @@ class TaskManager:
         self.engine.tasks = pd.concat([self.engine.tasks, new_task], ignore_index=True)
         self.engine.tasks.to_csv("tasks.csv", index=False)
         print(f"✅ Added task: {task_type} (ID: {new_id}, Complexity: {complexity}, Deadline: {deadline}h)")
+        return new_id
 
 if __name__ == "__main__":
     # Example usage