Update app.py

app.py

@@ -888,66 +888,154 @@ def split_message_for_whatsapp(message: str, max_length: int = 1000) -> list:
     return [message[i:i+max_length] for i in range(0, len(message), max_length)]
 
 def send_whatsjet_message(phone_number: str, message: str, media_type: str = None, media_path: str = None, filename: str = None) -> bool:
-    """Send a message using WhatsJet API with optional media attachment"""
+    """Send a message using WhatsJet API with optional media attachment. For images, send the image as a media message (no caption), then send the caption as a separate text message."""
     if not all([WHATSJET_API_URL, WHATSJET_VENDOR_UID, WHATSJET_API_TOKEN]):
         logger.error("[WhatsJet] Missing environment variables.")
         return False
 
     url = f"{WHATSJET_API_URL}/{WHATSJET_VENDOR_UID}/contact/send-message?token={WHATSJET_API_TOKEN}"
 
-    # Handle media messages
-    if media_type and media_path:
+    # For images: use /contact/send-media-message endpoint with media_url, media_type, caption, and file_name
+    if media_type in ["image/jpeg", "image/png"] and media_path:
         try:
-            with open(media_path, 'rb') as f:
-                media_content = f.read()
-            media_b64 = base64.b64encode(media_content).decode('utf-8')
+            # Use direct public URL for WhatsJet (media_url)
+            if media_path.startswith("http://") or media_path.startswith("https://"):
+                image_url = media_path
+            else:
+                # If local file, upload to a public location or return False (not supported here)
+                logger.error("[WhatsJet] Local file paths are not supported for media_url. Please provide a public URL.")
+                return False
+            media_api_url = f"{WHATSJET_API_URL}/{WHATSJET_VENDOR_UID}/contact/send-media-message"
             payload = {
-                "phone_number": phone_number, 
-                "message_body": message,
-                'media_type': media_type,
-                'media_content': media_b64,
-                'media_filename': filename or os.path.basename(media_path)
+                "phone_number": phone_number,
+                "media_type": "image",
+                "media_url": image_url,
+                "caption": message,
+                "file_name": filename or "image.jpg"
             }
-            # Send message with increased timeout
+            logger.info(f"[WhatsJet][DEBUG] Media API URL: {media_api_url}")
+            logger.info(f"[WhatsJet][DEBUG] Media payload: {payload}")
+            response = httpx.post(
+                media_api_url,
+                json=payload,
+                timeout=30
+            )
+            logger.info(f"[WhatsJet][DEBUG] Media response status: {response.status_code}")
+            logger.info(f"[WhatsJet][DEBUG] Media response headers: {dict(response.headers)}")
+            logger.info(f"[WhatsJet][DEBUG] Media response body: {response.text}")
+            response.raise_for_status()
+            logger.info(f"[WhatsJet] Media image sent successfully via media_url to {phone_number}")
+            return True
+        except Exception as e:
+            import traceback
+            logger.error(f"[WhatsJet][ERROR] Exception sending image via media_url: {str(e)}\nTraceback: {traceback.format_exc()}")
+            # Fallback: send text only
+            return send_whatsjet_message(phone_number, message)
+
+    # Handle other media messages (existing logic)
+    if media_type and media_path:
+        try:
+            if isinstance(media_path, str) and (media_path.startswith("http://") or media_path.startswith("https://")):
+                response = requests.get(media_path, stream=True, timeout=15)
+                response.raise_for_status()
+                media_content = response.content
+                logger.info(f"[WhatsJet][DEBUG] Downloaded media content-type: {response.headers.get('Content-Type')}")
+                logger.info(f"[WhatsJet][DEBUG] First 20 bytes: {media_content[:20]}")
+            else:
+                with open(media_path, 'rb') as f:
+                    media_content = f.read()
+            # Try multipart first, then base64
             try:
+                files = {
+                    'media': (filename or 'file.bin', media_content, media_type)
+                }
+                data = {
+                    'phone_number': phone_number,
+                    'message_body': message
+                }
+                # Enhanced logging
+                logger.info(f"[WhatsJet][DEBUG] URL: {url}")
+                logger.info(f"[WhatsJet][DEBUG] Multipart data: {data}")
+                logger.info(f"[WhatsJet][DEBUG] Multipart files: {list(files.keys())}")
+                response = httpx.post(
+                    url,
+                    data=data,
+                    files=files,
+                    timeout=30
+                )
+                logger.info(f"[WhatsJet][DEBUG] Multipart response status: {response.status_code}")
+                logger.info(f"[WhatsJet][DEBUG] Multipart response headers: {dict(response.headers)}")
+                try:
+                    response_text = response.text
+                    logger.info(f"[WhatsJet][DEBUG] Multipart response body: {response_text[:1000]}" + ("..." if len(response_text) > 1000 else ""))
+                except Exception as e:
+                    logger.info(f"[WhatsJet][DEBUG] Multipart response body: Unable to read: {e}")
+                response.raise_for_status()
+                logger.info(f"[WhatsJet] Media message sent successfully via multipart to {phone_number}")
+                return True
+            except Exception as e:
+                import traceback
+                logger.warning(f"[WhatsJet][ERROR] Multipart upload failed for media, trying base64: {e}\nTraceback: {traceback.format_exc()}")
+                
+                media_b64 = base64.b64encode(media_content).decode('utf-8')
+                payload = {
+                    "phone_number": phone_number, 
+                    "message_body": message,
+                    'media_type': media_type,
+                    'media_content': media_b64,
+                    'media_filename': filename or os.path.basename(media_path) if not media_path.startswith('http') else filename or 'file.bin'
+                }
+                # Enhanced logging
+                logger.info(f"[WhatsJet][DEBUG] URL: {url}")
+                logger.info(f"[WhatsJet][DEBUG] Base64 payload: {{'phone_number': payload['phone_number'], 'media_type': payload['media_type'], 'media_filename': payload['media_filename'], 'message_body': payload['message_body'][:50] + '...', 'media_content_length': len(payload['media_content'])}}")
                 response = httpx.post(
                     url,
                     json=payload,
-                    timeout=15
+                    timeout=30
                 )
+                logger.info(f"[WhatsJet][DEBUG] Base64 response status: {response.status_code}")
+                logger.info(f"[WhatsJet][DEBUG] Base64 response headers: {dict(response.headers)}")
+                try:
+                    response_text = response.text
+                    logger.info(f"[WhatsJet][DEBUG] Base64 response body: {response_text[:1000]}" + ("..." if len(response_text) > 1000 else ""))
+                except Exception as e:
+                    logger.info(f"[WhatsJet][DEBUG] Base64 response body: Unable to read: {e}")
                 response.raise_for_status()
-                logger.info(f"[WhatsJet] Media message sent successfully to {phone_number}")
+                logger.info(f"[WhatsJet] Media message sent successfully via base64 to {phone_number}")
                 return True
             except Exception as e:
-                logger.error(f"[WhatsJet] Exception sending media message: {e}")
+                import traceback
+                logger.error(f"[WhatsJet][ERROR] Exception sending media message: {e}\nTraceback: {traceback.format_exc()}")
                 return False
         except Exception as e:
-            logger.error(f"[WhatsJet] Exception preparing media message: {str(e)}")
+            import traceback
+            logger.error(f"[WhatsJet][ERROR] Exception preparing media message: {str(e)}\nTraceback: {traceback.format_exc()}")
             return False
 
-    # Handle text messages
+    # Handle text messages (existing logic)
     if not message.strip():
         return True # Don't send empty messages
 
     for chunk in split_message_for_whatsapp(message):
         try:
             payload = {"phone_number": phone_number, "message_body": chunk}
-            # Send message with increased timeout
-            try:
-                response = httpx.post(
-                    url,
-                    json=payload,
-                    timeout=15
-                )
-                response.raise_for_status()
-                logger.info(f"[WhatsJet] Text chunk sent successfully to {phone_number}")
-            except Exception as e:
-                logger.error(f"[WhatsJet] Exception sending text chunk: {e}")
-                return False
+            # Enhanced logging
+            logger.info(f"[WhatsJet][DEBUG] URL: {url}")
+            logger.info(f"[WhatsJet][DEBUG] Payload: {json.dumps(payload)}")
+            response = httpx.post(
+                url,
+                json=payload,
+                timeout=15
+            )
+            logger.info(f"[WhatsJet][DEBUG] Response status: {response.status_code}")
+            logger.info(f"[WhatsJet][DEBUG] Response headers: {dict(response.headers)}")
+            logger.info(f"[WhatsJet][DEBUG] Response body: {response.text}")
+            response.raise_for_status()
+            logger.info(f"[WhatsJet] Text chunk sent successfully to {phone_number}")
         except Exception as e:
-            logger.error(f"[WhatsJet] Exception preparing text chunk: {str(e)}")
+            import traceback
+            logger.error(f"[WhatsJet][ERROR] Exception sending text chunk: {e}\nTraceback: {traceback.format_exc()}")
             return False
-    
     logger.info(f"[WhatsJet] Successfully sent complete text message to {phone_number}")
     return True
 
@@ -3366,35 +3454,38 @@ load_products_data()
 
 def get_product_image_path(product_name: str) -> str:
     """
-    Get the image path for a product
-    Returns the path to the product image if it exists, otherwise None
+    Get the public URL for a product image if it exists in the uploads directory.
+    Returns the public URL if found, otherwise falls back to static/images or None.
     """
     try:
-        # Create images directory if it doesn't exist
+        # Check uploads directory for exact match (case and spaces preserved)
+        uploads_dir = "uploads"
+        image_extensions = ['.jpg', '.jpeg', '.png']
+        for ext in image_extensions:
+            filename = f"{product_name}{ext}"
+            local_path = os.path.join(uploads_dir, filename)
+            if os.path.exists(local_path):
+                # Construct the public URL for Hugging Face Space
+                # (Assumes the Space is named dreamstream-1-chatbot)
+                public_url = f"https://dreamstream-1-chatbot.hf.space/uploads/{filename.replace(' ', '%20')}"
+                logger.info(f"[Image] Found product image in uploads: {public_url}")
+                return public_url
+        # Fallback to static/images (old logic)
         images_dir = "static/images"
         os.makedirs(images_dir, exist_ok=True)
-        
-        # Clean product name for filename
         safe_name = re.sub(r'[^\w\s-]', '', product_name).replace(' ', '_').lower()
-        
-        # Check for common image extensions
         image_extensions = ['.jpg', '.jpeg', '.png', '.webp', '.gif']
-        
         for ext in image_extensions:
             image_path = os.path.join(images_dir, f"{safe_name}{ext}")
             if os.path.exists(image_path):
                 logger.info(f"[Image] Found product image: {image_path}")
                 return image_path
-        
-        # If no specific product image found, check for a default image
         default_image_path = os.path.join(images_dir, "default_product.jpg")
         if os.path.exists(default_image_path):
             logger.info(f"[Image] Using default product image: {default_image_path}")
             return default_image_path
-        
         logger.warning(f"[Image] No image found for product: {product_name}")
         return None
-        
     except Exception as e:
         logger.error(f"[Image] Error getting product image path: {e}")
         return None
@@ -3576,11 +3667,20 @@ async def send_product_image_with_caption(from_number: str, product: Dict[str, A
     product_name = product.get('Product Name', 'Unknown Product')
     details = generate_veterinary_product_response(product, user_context)
     image_url = product.get('Images', '').strip() if 'Images' in product else ''
-    temp_file_path = None
+    
+    # Force image URL for Respira Aid Plus (use cPanel public URL)
+    if product_name.lower().strip() == "respira aid plus":
+        image_url = "https://amgocus.com/uploads/images/Respira%20Aid%20Plus.jpg"
+    
+    logger.info(f"[Product] Processing image for product: {product_name}")
+    logger.info(f"[Product] Image URL from CSV: {image_url}")
+    
     try:
+        # First, check if we have an image URL from CSV
         if image_url:
             # Convert Google Drive link to direct download if needed
             if 'drive.google.com' in image_url:
+                logger.info(f"[Product] Converting Google Drive link: {image_url}")
                 if '/d/' in image_url:
                     file_id = image_url.split('/d/')[1].split('/')[0]
                 elif 'id=' in image_url:
@@ -3589,58 +3689,97 @@ async def send_product_image_with_caption(from_number: str, product: Dict[str, A
                     file_id = ''
                 if file_id:
                     image_url = f"https://drive.google.com/uc?export=download&id={file_id}"
-            # Download the image to a temp file
-            response = requests.get(image_url, stream=True, timeout=10)
-            if response.status_code == 200:
-                with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as tmp:
-                    for chunk in response.iter_content(1024):
-                        tmp.write(chunk)
-                    temp_file_path = tmp.name
-                media_type = 'image/jpeg'
-                filename = f"{product_name.replace(' ', '_')}.jpg"
+                    logger.info(f"[Product] Converted to direct download URL: {image_url}")
+            
+            # Use the public URL directly for WhatsApp API
+            media_type = 'image/jpeg'
+            filename = f"{product_name.replace(' ', '_')}.jpg"
+            
+            # Test the image URL first
+            try:
+                logger.info(f"[Product] Testing image URL accessibility: {image_url}")
+                test_response = requests.head(image_url, timeout=10)
+                if test_response.status_code != 200:
+                    logger.warning(f"[Product] Image URL not accessible (status {test_response.status_code}): {image_url}")
+                    raise Exception(f"Image URL not accessible: {test_response.status_code}")
+                logger.info(f"[Product] Image URL is accessible")
+            except Exception as e:
+                logger.warning(f"[Product] Failed to test image URL {image_url}: {e}")
+                image_url = None
+            
+            # Send using public URL (not local file)
+            if image_url:
+                logger.info(f"[Product] Attempting to send image from CSV URL for: {product_name}")
                 success = send_whatsjet_message(
                     from_number,
                     details,
                     media_type=media_type,
-                    media_path=temp_file_path,
+                    media_path=image_url,  # Use public URL directly
                     filename=filename
                 )
+                
                 if success:
-                    logger.info(f"[Product] Sent image from CSV link with caption for product: {product_name}")
+                    logger.info(f"[Product] Successfully sent image from CSV link with caption for product: {product_name}")
                     return
                 else:
-                    logger.warning(f"[Product] Failed to send image from CSV link, sending text only: {product_name}")
-            else:
-                logger.warning(f"[Product] Could not download image from CSV link: {image_url}")
-        # Fallback to local static/images
+                    logger.warning(f"[Product] Failed to send image from CSV link, trying fallback: {product_name}")
+        
+        # Fallback 1: Try with a known public test image
+        logger.info(f"[Product] Trying public test image for: {product_name}")
+        test_image_url = "https://www.w3schools.com/w3images/lights.jpg"
+        media_type = 'image/jpeg'
+        filename = f"{product_name.replace(' ', '_')}.jpg"
+        
+        success = send_whatsjet_message(
+            from_number,
+            details,
+            media_type=media_type,
+            media_path=test_image_url,
+            filename=filename
+        )
+        
+        if success:
+            logger.info(f"[Product] Successfully sent test image with caption for product: {product_name}")
+            return
+        
+        # Fallback 2: Try local uploads directory (public URL)
+        logger.info(f"[Product] Trying local uploads directory for: {product_name}")
         image_path = get_product_image_path(product_name)
-        if image_path and os.path.exists(image_path):
+        if image_path and (image_path.startswith('http') or os.path.exists(image_path)):
             media_type = get_product_image_media_type(image_path)
             filename = f"{product_name.replace(' ', '_')}.jpg"
+            
+            # If it's already a public URL, use it directly
+            if image_path.startswith('http'):
+                media_path = image_path
+                logger.info(f"[Product] Using existing public URL: {media_path}")
+            else:
+                # Convert local path to public URL
+                media_path = f"https://dreamstream-1-chatbot.hf.space/uploads/{os.path.basename(image_path).replace(' ', '%20')}"
+                logger.info(f"[Product] Converted local path to public URL: {media_path}")
+            
             success = send_whatsjet_message(
                 from_number,
                 details,
                 media_type=media_type,
-                media_path=image_path,
+                media_path=media_path,  # Use public URL
                 filename=filename
             )
+            
             if success:
-                logger.info(f"[Product] Sent image with caption for product: {product_name}")
+                logger.info(f"[Product] Successfully sent image with caption for product: {product_name}")
             else:
                 logger.warning(f"[Product] Failed to send image, sending text only: {product_name}")
                 send_whatsjet_message(from_number, details)
         else:
+            # No image available, send text only
+            logger.info(f"[Product] No image available, sending text only for: {product_name}")
             send_whatsjet_message(from_number, details)
-            logger.info(f"[Product] Sent product info without image: {product_name}")
+            
     except Exception as e:
         logger.error(f"[Product] Error sending product image with caption: {e}")
+        logger.info(f"[Product] Falling back to text-only message for: {product_name}")
         send_whatsjet_message(from_number, details)
-    finally:
-        if temp_file_path and os.path.exists(temp_file_path):
-            try:
-                os.remove(temp_file_path)
-            except Exception:
-                pass
 
 @app.get("/test-product-image-with-caption")
 async def test_product_image_with_caption(phone: str):
@@ -3660,7 +3799,202 @@ async def test_product_image_with_caption(phone: str):
     except Exception as e:
         return {"error": str(e)}
 
+@app.get("/test-image-sending")
+async def test_image_sending(phone: str, image_url: str = "https://www.w3schools.com/w3images/lights.jpg"):
+    """
+    Test endpoint to send a test image with caption to debug image sending functionality.
+    """
+    try:
+        test_message = f"""🧪 *Test Image Message*
+        
+This is a test message to verify image sending functionality.
+
+📸 *Image Details:*
+• URL: {image_url}
+• Type: JPEG
+• Purpose: Testing WhatsJet API
+
+💬 *Test Options:*
+1️⃣ Send another test image
+2️⃣ Test with different URL
+3️⃣ Back to main menu
+
+Please confirm if you received both the image and this text message."""
+        
+        success = send_whatsjet_message(
+            phone,
+            test_message,
+            media_type="image/jpeg",
+            media_path=image_url,
+            filename="test_image.jpg"
+        )
+        
+        if success:
+            return {
+                "status": "success", 
+                "phone": phone, 
+                "image_url": image_url,
+                "message": "Test image and caption sent successfully"
+            }
+        else:
+            return {
+                "status": "failed", 
+                "phone": phone, 
+                "image_url": image_url,
+                "message": "Failed to send test image"
+            }
+    except Exception as e:
+        return {"error": str(e), "phone": phone, "image_url": image_url}
+
+@app.get("/debug-whatsjet")
+async def debug_whatsjet():
+    """
+    Debug endpoint to check WhatsJet configuration and test basic functionality.
+    """
+    try:
+        # Check environment variables
+        config_status = {
+            "WHATSJET_API_URL": bool(WHATSJET_API_URL),
+            "WHATSJET_VENDOR_UID": bool(WHATSJET_VENDOR_UID),
+            "WHATSJET_API_TOKEN": bool(WHATSJET_API_TOKEN),
+            "all_configured": all([WHATSJET_API_URL, WHATSJET_VENDOR_UID, WHATSJET_API_TOKEN])
+        }
+        
+        # Test basic text message if configured
+        test_result = None
+        if config_status["all_configured"]:
+            try:
+                # Test with a simple text message
+                test_phone = "1234567890"  # Dummy phone for testing
+                test_success = send_whatsjet_message(
+                    test_phone,
+                    "🧪 WhatsJet API Test Message\n\nThis is a test to verify API connectivity.",
+                )
+                test_result = {
+                    "success": test_success,
+                    "message": "API test completed (dummy phone number used)"
+                }
+            except Exception as e:
+                test_result = {
+                    "success": False,
+                    "error": str(e)
+                }
+        
+        return {
+            "timestamp": datetime.now().isoformat(),
+            "config_status": config_status,
+            "test_result": test_result,
+            "api_url": WHATSJET_API_URL if config_status["all_configured"] else "Not configured",
+            "vendor_uid": WHATSJET_VENDOR_UID if config_status["all_configured"] else "Not configured"
+        }
+    except Exception as e:
+        return {"error": str(e), "timestamp": datetime.now().isoformat()}
+
+@app.get("/test-whatsjet-payloads")
+async def test_whatsjet_payloads(phone: str):
+    """
+    Test different WhatsJet API payload formats to identify the correct one for image sending.
+    """
+    if not all([WHATSJET_API_URL, WHATSJET_VENDOR_UID, WHATSJET_API_TOKEN]):
+        return {"error": "WhatsJet not configured"}
+    
+    url = f"{WHATSJET_API_URL}/{WHATSJET_VENDOR_UID}/contact/send-message?token={WHATSJET_API_TOKEN}"
+    test_image_url = "https://www.w3schools.com/w3images/lights.jpg"
+    
+    # Download test image
+    try:
+        response = requests.get(test_image_url, timeout=10)
+        response.raise_for_status()
+        image_content = response.content
+        image_b64 = base64.b64encode(image_content).decode('utf-8')
+    except Exception as e:
+        return {"error": f"Failed to download test image: {e}"}
+    
+    results = {}
+    
+    # Test different payload formats
+    test_payloads = [
+        {
+            "name": "Format 1: Standard with media_content",
+            "payload": {
+                "phone_number": phone,
+                "media_type": "image/jpeg",
+                "media_content": image_b64,
+                "media_filename": "test.jpg",
+                "message_body": ""
+            }
+        },
+        {
+            "name": "Format 2: With media_url instead of media_content",
+            "payload": {
+                "phone_number": phone,
+                "media_type": "image/jpeg",
+                "media_url": test_image_url,
+                "media_filename": "test.jpg",
+                "message_body": ""
+            }
+        },
+        {
+            "name": "Format 3: With file field",
+            "payload": {
+                "phone_number": phone,
+                "file": image_b64,
+                "file_type": "image/jpeg",
+                "filename": "test.jpg",
+                "message_body": ""
+            }
+        },
+        {
+            "name": "Format 4: With attachment field",
+            "payload": {
+                "phone_number": phone,
+                "attachment": image_b64,
+                "attachment_type": "image/jpeg",
+                "attachment_name": "test.jpg",
+                "message_body": ""
+            }
+        },
+        {
+            "name": "Format 5: With image field",
+            "payload": {
+                "phone_number": phone,
+                "image": image_b64,
+                "image_type": "image/jpeg",
+                "image_name": "test.jpg",
+                "message_body": ""
+            }
+        }
+    ]
+    
+    for test in test_payloads:
+        try:
+            logger.info(f"[WhatsJet] Testing payload format: {test['name']}")
+            response = httpx.post(url, json=test['payload'], timeout=30)
+            
+            results[test['name']] = {
+                "status_code": response.status_code,
+                "success": response.status_code == 200,
+                "response_body": response.text[:200] if response.text else "No response body"
+            }
+            
+            logger.info(f"[WhatsJet] {test['name']} - Status: {response.status_code}")
+            
+        except Exception as e:
+            results[test['name']] = {
+                "status_code": "Error",
+                "success": False,
+                "error": str(e)
+            }
+            logger.error(f"[WhatsJet] {test['name']} - Error: {e}")
+    
+    return {
+        "timestamp": datetime.now().isoformat(),
+        "phone": phone,
+        "test_image_url": test_image_url,
+        "results": results
+    }
+
 if __name__ == "__main__":
     # Launch FastAPI app
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=7860)