Add CropDrive integration: upload limits enforcement and analysis completion messaging

- Update cropdrive_integration.py to handle CONFIG messages with upload limits
- Add can_start_analysis() function to check upload limits before analysis
- Add get_upload_limit_info() helper function
- Update send_analysis_complete() to include ISO timestamp
- Update upload.py to enforce upload limits before allowing analysis
- Display upload usage information on upload page
- Update results.py to ensure ANALYSIS_COMPLETE message includes timestamp
- Handle unlimited plans (infinity/-1) properly

modules/results.py

@@ -625,15 +625,25 @@ def show_results_page():
                         analysis_type = 'leaf'
                     
                     # Send completion message
+                    # Get timestamp in ISO format
+                    timestamp = results_data.get('timestamp')
+                    if timestamp:
+                        if hasattr(timestamp, 'isoformat'):
+                            timestamp_str = timestamp.isoformat()
+                        else:
+                            timestamp_str = str(timestamp)
+                    else:
+                        timestamp_str = datetime.now().isoformat()
+                    
                     send_analysis_complete(
-                        title=f'Agricultural Analysis - {datetime.now().strftime("%Y-%m-%d %H:%M")}',
+                        title=f'Analysis Report - {datetime.now().strftime("%Y-%m-%d")}',
                         analysis_type=analysis_type,
                         summary=summary or "Comprehensive soil and leaf analysis completed successfully.",
                         recommendations_count=recommendations_count,
                         file_url=None,  # Could add URL to PDF if generated
                         analysis_data={
                             'resultId': results_data.get('id'),
-                            'timestamp': results_data.get('timestamp').isoformat() if hasattr(results_data.get('timestamp'), 'isoformat') else str(results_data.get('timestamp')),
+                            'timestamp': timestamp_str,
                             'status': 'completed'
                         }
                     )

modules/upload.py

@@ -1060,10 +1060,52 @@ def upload_section():
     
     land_yield_provided = land_size > 0 and current_yield > 0
     
+    # Check upload limits before allowing analysis
+    can_start = True
+    limit_info = None
+    try:
+        from utils.cropdrive_integration import can_start_analysis, get_upload_limit_info
+        can_start = can_start_analysis()
+        limit_info = get_upload_limit_info()
+    except ImportError:
+        # CropDrive integration not available, allow analysis
+        pass
+    except Exception:
+        # Error checking limits, allow analysis to proceed
+        pass
+    
     if soil_uploaded and leaf_uploaded and land_yield_provided:
-        if st.button(f"🚀 {t('upload_start_analysis')}", type="primary", use_container_width=True, key="start_analysis"):
+        # Show upload limit info if available
+        if limit_info:
+            uploads_used = limit_info.get('uploads_used', 0)
+            uploads_limit = limit_info.get('uploads_limit', 0)
+            uploads_remaining = limit_info.get('uploads_remaining', 0)
+            
+            if uploads_limit > 0:
+                if uploads_remaining == float('inf') or uploads_remaining == -1:
+                    st.info(f"📊 **Analyses:** Unlimited")
+                else:
+                    st.info(f"📊 **Analyses:** {uploads_used}/{uploads_limit} used ({uploads_remaining} remaining)")
+        
+        # Check if limit exceeded
+        if not can_start:
+            st.error("❌ **Analysis Limit Reached**")
+            st.info("💡 You have reached your analysis limit. Please upgrade your plan to continue analyzing lab reports.")
+            st.button(f"🚀 {t('upload_start_analysis')}", disabled=True, use_container_width=True, key="start_analysis_disabled_limit")
+        elif st.button(f"🚀 {t('upload_start_analysis')}", type="primary", use_container_width=True, key="start_analysis"):
             # Ensure files are valid before passing to analysis
             try:
+                # Double-check limit before starting (in case it changed)
+                try:
+                    from utils.cropdrive_integration import can_start_analysis
+                    if not can_start_analysis():
+                        st.error("❌ **Analysis Limit Reached**")
+                        st.info("💡 You have reached your analysis limit. Please upgrade your plan to continue analyzing lab reports.")
+                        st.stop()
+                except Exception:
+                    # If check fails, allow to proceed
+                    pass
+                
                 soil_file = st.session_state.soil_file
                 leaf_file = st.session_state.leaf_file
                 

utils/cropdrive_integration.py

@@ -43,7 +43,11 @@ def inject_parent_communication():
                     userId: data.userId,
                     plan: data.plan || 'none',
                     userEmail: data.userEmail || '',
-                    userName: data.userName || ''
+                    userName: data.userName || '',
+                    uploadsUsed: data.uploadsUsed || 0,
+                    uploadsLimit: data.uploadsLimit || 0,
+                    uploadLimitExceeded: data.uploadLimitExceeded || false,
+                    uploadsRemaining: data.uploadsRemaining !== undefined ? data.uploadsRemaining : (data.uploadsLimit || 0) - (data.uploadsUsed || 0)
                 };
                 currentLanguage = userConfig.language;
                 if (currentLanguage !== 'en' && currentLanguage !== 'ms') {
@@ -56,6 +60,10 @@ def inject_parent_communication():
                 localStorage.setItem('cropdrive_userEmail', userConfig.userEmail || '');
                 localStorage.setItem('cropdrive_userName', userConfig.userName || '');
                 localStorage.setItem('cropdrive_plan', userConfig.plan || 'none');
+                localStorage.setItem('cropdrive_uploadsUsed', String(userConfig.uploadsUsed));
+                localStorage.setItem('cropdrive_uploadsLimit', String(userConfig.uploadsLimit));
+                localStorage.setItem('cropdrive_uploadLimitExceeded', String(userConfig.uploadLimitExceeded));
+                localStorage.setItem('cropdrive_uploadsRemaining', String(userConfig.uploadsRemaining));
                 
                 // Update URL parameters
                 const url = new URL(window.location.href);
@@ -67,8 +75,18 @@ def inject_parent_communication():
                 url.searchParams.set('userEmail', userConfig.userEmail || '');
                 url.searchParams.set('userName', userConfig.userName || '');
                 url.searchParams.set('plan', userConfig.plan || 'none');
+                url.searchParams.set('uploadsUsed', String(userConfig.uploadsUsed));
+                url.searchParams.set('uploadsLimit', String(userConfig.uploadsLimit));
+                url.searchParams.set('uploadLimitExceeded', String(userConfig.uploadLimitExceeded));
+                url.searchParams.set('uploadsRemaining', String(userConfig.uploadsRemaining));
                 window.history.replaceState({}, '', url);
                 
+                // Notify parent that config was received
+                window.parent.postMessage({
+                    type: 'CONFIG_RECEIVED',
+                    userId: userConfig.userId
+                }, '*');
+                
                 // Notify parent that language was set
                 window.parent.postMessage({
                     type: 'STREAMLIT_LANGUAGE_UPDATE',
@@ -115,6 +133,11 @@ def inject_parent_communication():
             const userIdParam = urlParams.get('userId');
             const userEmailParam = urlParams.get('userEmail');
             const userNameParam = urlParams.get('userName');
+            const uploadsUsedParam = urlParams.get('uploadsUsed');
+            const uploadsLimitParam = urlParams.get('uploadsLimit');
+            const uploadLimitExceededParam = urlParams.get('uploadLimitExceeded');
+            const uploadsRemainingParam = urlParams.get('uploadsRemaining');
+            
             if (userIdParam) {
                 localStorage.setItem('cropdrive_userId', userIdParam);
             }
@@ -124,6 +147,18 @@ def inject_parent_communication():
             if (userNameParam) {
                 localStorage.setItem('cropdrive_userName', userNameParam);
             }
+            if (uploadsUsedParam !== null) {
+                localStorage.setItem('cropdrive_uploadsUsed', uploadsUsedParam);
+            }
+            if (uploadsLimitParam !== null) {
+                localStorage.setItem('cropdrive_uploadsLimit', uploadsLimitParam);
+            }
+            if (uploadLimitExceededParam !== null) {
+                localStorage.setItem('cropdrive_uploadLimitExceeded', uploadLimitExceededParam);
+            }
+            if (uploadsRemainingParam !== null) {
+                localStorage.setItem('cropdrive_uploadsRemaining', uploadsRemainingParam);
+            }
         });
     })();
     </script>
@@ -158,6 +193,37 @@ def initialize_integration():
     features_str = query_params.get('features', '')
     features = features_str.split(',') if features_str else []
     
+    # Get upload limits from URL parameters
+    uploads_used = query_params.get('uploadsUsed', '0')
+    uploads_limit = query_params.get('uploadsLimit', '0')
+    upload_limit_exceeded = query_params.get('uploadLimitExceeded', 'false')
+    uploads_remaining = query_params.get('uploadsRemaining', '0')
+    
+    # Convert to appropriate types
+    try:
+        uploads_used = int(uploads_used) if uploads_used else 0
+    except (ValueError, TypeError):
+        uploads_used = 0
+    
+    try:
+        uploads_limit = int(uploads_limit) if uploads_limit else 0
+    except (ValueError, TypeError):
+        uploads_limit = 0
+    
+    try:
+        upload_limit_exceeded = upload_limit_exceeded.lower() == 'true' if upload_limit_exceeded else False
+    except (AttributeError, ValueError):
+        upload_limit_exceeded = False
+    
+    try:
+        uploads_remaining_str = str(uploads_remaining)
+        if uploads_remaining_str.lower() == 'infinity' or uploads_remaining_str == '-1':
+            uploads_remaining = float('inf')
+        else:
+            uploads_remaining = int(uploads_remaining) if uploads_remaining else 0
+    except (ValueError, TypeError):
+        uploads_remaining = 0
+    
     # Store user config in session state
     if 'user_config' not in st.session_state:
         st.session_state.user_config = {
@@ -178,6 +244,12 @@ def initialize_integration():
     st.session_state.user_config['userEmail'] = user_email
     st.session_state.user_config['userName'] = user_name
     
+    # Store upload limits in session state
+    st.session_state.uploads_used = uploads_used
+    st.session_state.uploads_limit = uploads_limit
+    st.session_state.upload_limit_exceeded = upload_limit_exceeded
+    st.session_state.uploads_remaining = uploads_remaining
+    
     return current_lang, user_plan, features
 
 # ============================================================================
@@ -203,20 +275,30 @@ def send_analysis_complete(
         file_url: URL to analysis file/image (optional)
         analysis_data: Additional analysis data dict (optional)
     """
+    from datetime import datetime
+    
     # Include user ID in the analysis complete message
     user_id = get_user_id()
     user_email = get_user_email()
     
+    # Ensure analysis_data includes timestamp if not already present
+    if analysis_data is None:
+        analysis_data = {}
+    
+    # Add timestamp if not already in analysis_data
+    if 'timestamp' not in analysis_data:
+        analysis_data['timestamp'] = datetime.now().isoformat()
+    
     message = {
         'type': 'ANALYSIS_COMPLETE',
+        'userId': user_id,
         'title': title,
         'analysisType': analysis_type,
         'summary': summary or '',
         'recommendationsCount': recommendations_count,
         'fileUrl': file_url,
         'analysisData': analysis_data or {},
-        'userId': user_id,
-        'userEmail': user_email
+        'timestamp': datetime.now().isoformat()
     }
     
     # Send to all allowed origins
@@ -320,6 +402,51 @@ def get_user_name():
         user_name = st.session_state.get('user_config', {}).get('userName', '')
     return user_name
 
+def can_start_analysis():
+    """
+    Check if user can start a new analysis based on upload limits
+    
+    Returns:
+        True if analysis can start, False otherwise
+    """
+    # Check if upload limit is exceeded
+    upload_limit_exceeded = st.session_state.get('upload_limit_exceeded', False)
+    if upload_limit_exceeded:
+        return False
+    
+    # Check remaining uploads
+    uploads_remaining = st.session_state.get('uploads_remaining', 0)
+    
+    # If uploads_remaining is infinity or -1, allow unlimited analyses
+    if uploads_remaining == float('inf') or uploads_remaining == -1:
+        return True
+    
+    # If uploads_remaining is 0 or less, block analysis
+    if uploads_remaining <= 0:
+        return False
+    
+    # Otherwise, allow analysis
+    return True
+
+def get_upload_limit_info():
+    """
+    Get upload limit information for display
+    
+    Returns:
+        Dictionary with upload limit information
+    """
+    uploads_used = st.session_state.get('uploads_used', 0)
+    uploads_limit = st.session_state.get('uploads_limit', 0)
+    upload_limit_exceeded = st.session_state.get('upload_limit_exceeded', False)
+    uploads_remaining = st.session_state.get('uploads_remaining', 0)
+    
+    return {
+        'uploads_used': uploads_used,
+        'uploads_limit': uploads_limit,
+        'upload_limit_exceeded': upload_limit_exceeded,
+        'uploads_remaining': uploads_remaining
+    }
+
 def send_language_change(new_language: str):
     """Send language change notification to parent window when language changes within Streamlit"""
     # Validate language