Update app.py

app.py

@@ -90,11 +90,32 @@ def generate_pdf(record_data):
         logger.debug("Generating PDF...")
         pdf_file = BytesIO()
         c = canvas.Canvas(pdf_file, pagesize=letter)
-        c.drawString(100, 750, f"Project Title: {record_data['project_title']}")
-        c.drawString(100, 730, f"Estimated Duration: {record_data['estimated_duration']} days")
-        c.drawString(100, 710, f"AI Plan Score: {record_data['ai_plan_score']}%")
-        c.drawString(100, 690, f"Status: {record_data['status']}")
-        c.drawString(100, 670, f"Risk Tags: {record_data['risk_tags']}")
+        
+        # Add project details
+        c.setFont("Helvetica-Bold", 14)
+        c.drawString(100, 750, "Project Summary Report")
+        c.setFont("Helvetica", 12)
+        
+        y_position = 720
+        for key, value in record_data.items():
+            if key == "risk_tags":
+                continue  # We'll handle risk tags separately
+            
+            c.drawString(100, y_position, f"{key.replace('_', ' ').title()}: {value}")
+            y_position -= 20
+        
+        # Add risk tags section
+        if "risk_tags" in record_data:
+            c.setFont("Helvetica-Bold", 12)
+            c.drawString(100, y_position - 20, "Risk Analysis:")
+            c.setFont("Helvetica", 10)
+            
+            risk_tags = record_data["risk_tags"].split("\n")
+            for tag in risk_tags:
+                if tag.strip():
+                    c.drawString(120, y_position - 40, tag)
+                    y_position -= 15
+        
         c.save()
         pdf_file.seek(0)
         logger.debug("PDF generated successfully.")
@@ -114,8 +135,8 @@ def upload_pdf_to_salesforce(pdf_file, project_title, record_id=None):
         encoded_pdf_data = base64.b64encode(pdf_file.getvalue()).decode('utf-8')
         logger.debug(f"Uploading PDF for project: {project_title}, record ID: {record_id}")
         content_version_data = {
-            "Title": f"{project_title} - Gantt Chart PDF",
-            "PathOnClient": f"{project_title}_Gantt_Chart.pdf",
+            "Title": f"{project_title} - Project Report",
+            "PathOnClient": f"{project_title}_Report.pdf",
             "VersionData": encoded_pdf_data,
         }
         
@@ -194,14 +215,14 @@ def send_to_salesforce(project_title, gantt_chart_url, ai_plan_score, estimated_
         new_record_id = project_record['id']
         logger.info(f"Created new Salesforce record with ID: {new_record_id}")
         return new_record_id
-    
+
     except Exception as e:
         logger.error(f"Error sending data to Salesforce: {str(e)}", exc_info=True)
         if hasattr(e, 'content') and e.content:
             logger.error(f"Salesforce API response: {e.content}")
         return None
 
-# Function to generate Gantt chart
+# Function to generate Gantt chart and risk analysis
 def generate_project_timeline(boq_file, weather, workforce, location, project_title):
     temp_dir = None
     try:
@@ -210,36 +231,101 @@ def generate_project_timeline(boq_file, weather, workforce, location, project_ti
             raise ValueError("No file uploaded")
 
         temp_dir = tempfile.mkdtemp()
-        output_filename = f"gantt_chart_{project_title.replace(' ', '')}{id(boq_file)}.png"
+        output_filename = f"gantt_chart_{project_title.replace(' ', '_')}.png"
         output_path = os.path.join(temp_dir, output_filename)
         logger.debug(f"Gantt chart will be saved to: {output_path}")
 
+        # Read the BOQ file
         if isinstance(boq_file, str):
             df = pd.read_csv(boq_file)
         else:
             df = pd.read_csv(boq_file.name)
 
-        if "Task Name" not in df.columns or "Duration" not in df.columns:
-            raise ValueError("CSV must contain 'Task Name' and 'Duration' columns")
-
-        task_names = df["Task Name"].tolist()
-        task_durations = df["Duration"].tolist()
-        logger.debug(f"Tasks: {task_names}, Durations: {task_durations}")
-
-        fig, ax = plt.subplots(figsize=(10, 5))
-        ax.barh(task_names, task_durations, color="skyblue")
-        ax.set_xlabel("Duration (days)")
-        ax.set_title("Project Timeline Gantt Chart")
-        fig.savefig(output_path, format="png", bbox_inches="tight")
+        # Validate required columns
+        required_columns = ["Task Name", "Duration"]
+        missing_columns = [col for col in required_columns if col not in df.columns]
+        if missing_columns:
+            raise ValueError(f"CSV is missing required columns: {', '.join(missing_columns)}")
+
+        # Generate detailed risk analysis
+        risk_analysis = []
+        for _, row in df.iterrows():
+            task = row["Task Name"]
+            duration = row["Duration"]
+            
+            # Weather risk assessment
+            if weather.lower() == "rainy":
+                weather_impact = "High" if duration > 3 else "Medium"
+                weather_reason = "Prolonged rain exposure" if duration > 3 else "Some rain impact expected"
+            elif weather.lower() == "sunny":
+                weather_impact = "Low"
+                weather_reason = "Favorable working conditions"
+            else:  # cloudy
+                weather_impact = "Low"
+                weather_reason = "Mild weather impact"
+            
+            # Workforce risk assessment
+            if workforce < 10 and duration > 5:
+                workforce_impact = "High"
+                workforce_reason = "Insufficient workforce for task duration"
+            elif workforce < 15 and duration > 10:
+                workforce_impact = "Medium"
+                workforce_reason = "Workforce may be stretched for this duration"
+            else:
+                workforce_impact = "Low"
+                workforce_reason = "Adequate workforce available"
+            
+            # Overall risk assessment
+            overall_risk = "High" if "High" in [weather_impact, workforce_impact] else "Medium" if "Medium" in [weather_impact, workforce_impact] else "Low"
+            
+            risk_analysis.append(
+                f"Task: {task}\n"
+                f"- Duration: {duration} days\n"
+                f"- Weather Impact: {weather_impact} ({weather_reason})\n"
+                f"- Workforce Impact: {workforce_impact} ({workforce_reason})\n"
+                f"- Overall Risk: {overall_risk}\n"
+            )
+
+        risk_tags_str = "\n".join(risk_analysis)
+        
+        # Generate Gantt chart
+        plt.style.use('ggplot')
+        fig, ax = plt.subplots(figsize=(12, 6))
+        
+        # Color tasks based on risk level
+        colors = []
+        for _, row in df.iterrows():
+            duration = row["Duration"]
+            if weather.lower() == "rainy" and duration > 3:
+                colors.append('#ff6b6b')  # red for high risk
+            elif workforce < 10 and duration > 5:
+                colors.append('#ff6b6b')  # red for high risk
+            elif (weather.lower() == "rainy" and duration > 1) or (workforce < 15 and duration > 7):
+                colors.append('#ffd166')  # yellow for medium risk
+            else:
+                colors.append('#06d6a0')  # green for low risk
+        
+        ax.barh(df["Task Name"], df["Duration"], color=colors, edgecolor='black')
+        ax.set_xlabel("Duration (days)", fontweight='bold')
+        ax.set_ylabel("Tasks", fontweight='bold')
+        ax.set_title(f"Project Timeline: {project_title}\nLocation: {location} | Weather: {weather}", fontweight='bold')
+        
+        # Add risk legend
+        ax.text(0.95, 0.15, 
+                "Risk Levels:\n"
+                "Green = Low Risk\n"
+                "Yellow = Medium Risk\n"
+                "Red = High Risk",
+                transform=ax.transAxes, 
+                bbox=dict(facecolor='white', alpha=0.8),
+                verticalalignment='top',
+                horizontalalignment='right')
+        
+        plt.tight_layout()
+        fig.savefig(output_path, format="png", bbox_inches="tight", dpi=100)
         plt.close(fig)
 
-        risk_tags = [
-            f"{task} - {'High' if weather == 'rainy' and duration > 5 else 'Low'} Risk (Weather)"
-            for task, duration in zip(task_names, task_durations)
-        ]
-        risk_tags_str = "\n".join(risk_tags)
-        logger.debug(f"Generated risk tags: {risk_tags_str}")
-        logger.info("Gantt chart and risk tags generated successfully.")
+        logger.info("Gantt chart and risk analysis generated successfully.")
         return output_path, risk_tags_str, temp_dir
     except Exception as e:
         logger.error(f"Error generating project timeline: {str(e)}", exc_info=True)
@@ -255,16 +341,22 @@ def gradio_interface(boq_file, weather, workforce, location, project_title):
         if not boq_file:
             return None, "Error: No BOQ file uploaded"
 
+        # Validate workforce input
+        if workforce <= 0:
+            return None, "Error: Workforce size must be greater than 0"
+
         boq_file_path = boq_file.name if hasattr(boq_file, 'name') else boq_file
         file_path, risk_tags, temp_dir = generate_project_timeline(boq_file_path, weather, workforce, location, project_title)
         if not file_path:
             return None, f"Error: Failed to generate timeline: {risk_tags}"
 
+        # Calculate project metrics
         df = pd.read_csv(boq_file_path)
         estimated_duration = sum(df["Duration"])
         ai_plan_score = min(100, max(0, 100 - (estimated_duration / 100)))
         logger.debug(f"Estimated duration: {estimated_duration}, AI plan score: {ai_plan_score}")
 
+        # Create Salesforce record
         record_id = send_to_salesforce(
             project_title=project_title,
             gantt_chart_url="",
@@ -277,17 +369,22 @@ def gradio_interface(boq_file, weather, workforce, location, project_title):
         )
         
         if not record_id:
-            return None, f"Error: Failed to create Salesforce record - check logs for details\n\nRisk Tags:\n{risk_tags}"
+            return None, f"Error: Failed to create Salesforce record - check logs for details\n\n=== RISK ANALYSIS ===\n\n{risk_tags}"
 
+        # Upload BOQ file to Salesforce
         work_items_id = upload_file_to_salesforce(boq_file_path, "Boq_data.csv", record_id)
         if not work_items_id:
             logger.warning("Failed to upload BOQ file, but proceeding with record creation")
 
+        # Generate and upload PDF report
         record_data = {
             "project_title": project_title,
             "estimated_duration": estimated_duration,
             "ai_plan_score": ai_plan_score,
             "status": "Draft",
+            "location": location,
+            "weather": weather,
+            "workforce_size": workforce,
             "risk_tags": risk_tags,
         }
         pdf_file = generate_pdf(record_data)
@@ -300,6 +397,7 @@ def gradio_interface(boq_file, weather, workforce, location, project_title):
             if not pdf_content_id:
                 logger.warning("Failed to upload PDF, but proceeding with record creation")
 
+        # Update record with PDF URL
         update_result = send_to_salesforce(
             project_title=project_title,
             gantt_chart_url=pdf_url if pdf_url else "",
@@ -314,7 +412,8 @@ def gradio_interface(boq_file, weather, workforce, location, project_title):
         if not update_result:
             logger.warning("Failed to update record with PDF URL, but record was created")
 
-        image_content_id = upload_file_to_salesforce(fileLf_path, f"{project_title}_Gantt_Chart.png", record_id)
+        # Upload Gantt chart image
+        image_content_id = upload_file_to_salesforce(file_path, f"{project_title}_Gantt_Chart.png", record_id)
         image_url = None
         if image_content_id:
             sf = get_salesforce_connection()
@@ -322,8 +421,22 @@ def gradio_interface(boq_file, weather, workforce, location, project_title):
                 image_url = f"https://{sf.sf_instance}/sfc/servlet.shepherd/version/download/{image_content_id}"
                 logger.debug(f"Generated image URL: {image_url}")
 
+        # Format output message
+        output_message = (
+            f"=== PROJECT SUMMARY ===\n\n"
+            f"Project: {project_title}\n"
+            f"Location: {location}\n"
+            f"Weather: {weather}\n"
+            f"Workforce Size: {workforce}\n"
+            f"Estimated Duration: {estimated_duration} days\n"
+            f"AI Plan Score: {ai_plan_score:.1f}%\n\n"
+            f"Salesforce Record ID: {record_id}\n\n"
+            f"=== RISK ANALYSIS ===\n\n"
+            f"{risk_tags}"
+        )
+
         logger.info("Gradio interface completed successfully.")
-        return image_url if image_url else file_path, f"Successfully created Salesforce record ID: {record_id}\n\nRisk Tags:\n{risk_tags}"
+        return image_url if image_url else file_path, output_message
     except Exception as e:
         logger.error(f"Error in Gradio interface: {str(e)}", exc_info=True)
         return None, f"Error in Gradio interface: {str(e)}"
@@ -336,20 +449,32 @@ def gradio_interface(boq_file, weather, workforce, location, project_title):
 demo = gr.Blocks(theme="default")
 with demo:
     gr.Markdown("## AI Civil Work Planner")
-    gr.Markdown("Generate a project timeline (Gantt chart) and risk tags based on BOQ data and site parameters.")
+    gr.Markdown("Generate a project timeline (Gantt chart) and risk analysis based on BOQ data and site parameters.")
 
     with gr.Row():
         with gr.Column():
-            boq_file = gr.File(label="Upload BOQ Data (CSV format)")
-            weather = gr.Dropdown(label="Weather", choices=["sunny", "rainy", "cloudy"], value="sunny")
-            workforce = gr.Number(label="Workforce Size", value=10, precision=0)
-            location = gr.Textbox(label="Location", placeholder="Enter project location")
-            project_title = gr.Textbox(label="Project Title", placeholder="Enter project title")
-            submit_btn = gr.Button("Generate Timeline")
+            boq_file = gr.File(label="Upload BOQ Data (CSV format)", file_types=[".csv"])
+            weather = gr.Dropdown(label="Weather Condition", 
+                                choices=["Sunny", "Rainy", "Cloudy"], 
+                                value="Sunny")
+            workforce = gr.Number(label="Workforce Size", 
+                                value=10, 
+                                precision=0,
+                                minimum=1,
+                                maximum=100,
+                                step=1)
+            location = gr.Textbox(label="Location", 
+                                placeholder="Enter project location")
+            project_title = gr.Textbox(label="Project Title", 
+                                    placeholder="Enter project title")
+            submit_btn = gr.Button("Generate Project Plan", variant="primary")
 
         with gr.Column():
-            output_image = gr.Image(label="Gantt Chart")
-            risk_tags = gr.Textbox(label="Risk Tags and Salesforce Status")
+            output_image = gr.Image(label="Gantt Chart",
+                                  type="filepath")
+            risk_tags = gr.Textbox(label="Project Summary and Risk Analysis",
+                                 lines=20,
+                                 max_lines=50)
 
     submit_btn.click(
         fn=gradio_interface,
@@ -361,21 +486,21 @@ with demo:
 app = FastAPI()
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["https://aiplannerforcivilworktimel2-dev-ed.develop.lightning.force.com"],
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
-# Mount directory for temporary files (e.g., Gantt chart PNGs)
+# Mount directory for temporary files
 app.mount("/static", StaticFiles(directory=tempfile.gettempdir()), name="static")
 
-# Health check endpoint to verify server status
+# Health check endpoint
 @app.get("/health")
 async def health_check():
     return {"status": "healthy"}
 
-# FastAPI endpoint for processing BOQ files and interacting with Salesforce
+# FastAPI endpoint for processing BOQ files
 @app.post("/api/gradio_interface")
 async def api_gradio_interface(
     boq_file: UploadFile = File(...),
@@ -400,7 +525,6 @@ async def api_gradio_interface(
         df = pd.read_csv(boq_file_path)
         estimated_duration = sum(df["Duration"])
         ai_plan_score = min(100, max(0, 100 - (estimated_duration / 100)))
-        logger.debug(f"Estimated duration: {estimated_duration}, AI plan score: {ai_plan_score}")
 
         record_id = send_to_salesforce(
             project_title=project_title,
@@ -415,30 +539,27 @@ async def api_gradio_interface(
         
         if not record_id:
             return JSONResponse({
-                "error": f"Failed to create Salesforce record - check logs for details",
-                "text": f"Risk Tags:\n{risk_tags}"
+                "error": "Failed to create Salesforce record",
+                "text": f"Risk Analysis:\n\n{risk_tags}"
             }, status_code=500)
 
         work_items_id = upload_file_to_salesforce(boq_file_path, "Boq_data.csv", record_id)
-        if not work_items_id:
-            logger.warning("Failed to upload BOQ file, but proceeding with record creation")
-
+        
         record_data = {
             "project_title": project_title,
             "estimated_duration": estimated_duration,
             "ai_plan_score": ai_plan_score,
             "status": "Draft",
+            "location": location,
+            "weather": weather,
+            "workforce_size": workforce,
             "risk_tags": risk_tags,
         }
+        
         pdf_file = generate_pdf(record_data)
-        if not pdf_file:
-            logger.warning("Failed to generate PDF, but proceeding with record creation")
-
         pdf_content_id, pdf_url = None, None
         if pdf_file:
             pdf_content_id, pdf_url = upload_pdf_to_salesforce(pdf_file, project_title, record_id)
-            if not pdf_content_id:
-                logger.warning("Failed to upload PDF, but proceeding with record creation")
 
         update_result = send_to_salesforce(
             project_title=project_title,
@@ -451,8 +572,6 @@ async def api_gradio_interface(
             weather_type=weather,
             work_items_id=work_items_id if work_items_id else ""
         )
-        if not update_result:
-            logger.warning("Failed to update record with PDF URL, but record was created")
 
         image_content_id = upload_file_to_salesforce(file_path, f"{project_title}_Gantt_Chart.png", record_id)
         image_url = None
@@ -460,12 +579,23 @@ async def api_gradio_interface(
             sf = get_salesforce_connection()
             if sf:
                 image_url = f"https://{sf.sf_instance}/sfc/servlet.shepherd/version/download/{image_content_id}"
-                logger.debug(f"Generated image URL: {image_url}")
 
-        logger.info("API gradio interface completed successfully.")
+        output_message = (
+            f"=== PROJECT SUMMARY ===\n\n"
+            f"Project: {project_title}\n"
+            f"Location: {location}\n"
+            f"Weather: {weather}\n"
+            f"Workforce Size: {workforce}\n"
+            f"Estimated Duration: {estimated_duration} days\n"
+            f"AI Plan Score: {ai_plan_score:.1f}%\n\n"
+            f"Salesforce Record ID: {record_id}\n\n"
+            f"=== RISK ANALYSIS ===\n\n"
+            f"{risk_tags}"
+        )
+
         return JSONResponse({
             "image": image_url if image_url else f"/static/{os.path.basename(file_path)}",
-            "text": f"Successfully created Salesforce record ID: {record_id}\n\nRisk Tags:\n{risk_tags}"
+            "text": output_message
         })
     except Exception as e:
         logger.error(f"Error in API gradio interface: {str(e)}", exc_info=True)
@@ -473,7 +603,6 @@ async def api_gradio_interface(
     finally:
         if temp_dir and os.path.exists(temp_dir):
             shutil.rmtree(temp_dir)
-            logger.debug(f"Cleaned up temporary directory: {temp_dir}")
 
 if __name__ == "__main__":
     # Run Gradio UI