Update app.py

app.py

@@ -900,53 +900,123 @@ def send_whatsjet_message(phone_number: str, message: str, media_type: str = Non
         try:
             # Download image if it's a URL
             if 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 image content-type: {response.headers.get('Content-Type')}")
-                logger.info(f"[WhatsJet][DEBUG] First 20 bytes: {media_content[:20]}")
+                try:
+                    response = requests.get(media_path, stream=True, timeout=15)
+                    response.raise_for_status()
+                    media_content = response.content
+                    content_type = response.headers.get('Content-Type', '')
+                    logger.info(f"[WhatsJet][DEBUG] Downloaded image content-type: {content_type}")
+                    logger.info(f"[WhatsJet][DEBUG] Image size: {len(media_content)} bytes")
+                    logger.info(f"[WhatsJet][DEBUG] First 20 bytes: {media_content[:20]}")
+                    
+                    # Validate image content
+                    if len(media_content) == 0:
+                        logger.error("[WhatsJet] Downloaded image is empty")
+                        return False
+                        
+                    # Check if content is actually an image
+                    if not content_type.startswith('image/'):
+                        logger.warning(f"[WhatsJet] URL does not return an image: {content_type}")
+                        
+                except Exception as e:
+                    logger.error(f"[WhatsJet] Failed to download image from {media_path}: {e}")
+                    return False
             else:
-                with open(media_path, 'rb') as f:
-                    media_content = f.read()
-            media_b64 = base64.b64encode(media_content).decode('utf-8')
-            payload = {
-                "phone_number": phone_number,
-                "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 'image.jpg',
-                "message_body": ""  # No caption
-            }
-            # Send image (no caption)
+                try:
+                    with open(media_path, 'rb') as f:
+                        media_content = f.read()
+                    logger.info(f"[WhatsJet][DEBUG] Local image size: {len(media_content)} bytes")
+                except Exception as e:
+                    logger.error(f"[WhatsJet] Failed to read local image {media_path}: {e}")
+                    return False
+            
+            # Try method 1: Send as multipart form data with file upload
             try:
+                files = {
+                    'media': (filename or 'image.jpg', media_content, media_type)
+                }
+                data = {
+                    'phone_number': phone_number,
+                    'message_body': ''  # No caption with image
+                }
+                
+                logger.info(f"[WhatsJet] Attempting multipart upload for {phone_number}")
                 response = httpx.post(
                     url,
-                    json=payload,
-                    timeout=15
+                    data=data,
+                    files=files,
+                    timeout=30
                 )
                 response.raise_for_status()
-                logger.info(f"[WhatsJet] Media image sent successfully to {phone_number}")
+                logger.info(f"[WhatsJet] Media image sent successfully via multipart upload to {phone_number}")
+                
+                # Send caption as separate text message
+                if message.strip():
+                    for chunk in split_message_for_whatsapp(message):
+                        try:
+                            text_payload = {"phone_number": phone_number, "message_body": chunk}
+                            text_response = httpx.post(
+                                url,
+                                json=text_payload,
+                                timeout=15
+                            )
+                            text_response.raise_for_status()
+                            logger.info(f"[WhatsJet] Text chunk (caption) sent successfully to {phone_number}")
+                        except Exception as e:
+                            logger.error(f"[WhatsJet] Exception sending text chunk (caption): {e}")
+                            return False
+                return True
+                
             except Exception as e:
-                logger.error(f"[WhatsJet] Exception sending media image: {e}")
-                return False
-            # Send caption as a separate text message
-            if message.strip():
-                for chunk in split_message_for_whatsapp(message):
-                    try:
-                        text_payload = {"phone_number": phone_number, "message_body": chunk}
-                        text_response = httpx.post(
-                            url,
-                            json=text_payload,
-                            timeout=15
-                        )
-                        text_response.raise_for_status()
-                        logger.info(f"[WhatsJet] Text chunk (caption) sent successfully to {phone_number}")
-                    except Exception as e:
-                        logger.error(f"[WhatsJet] Exception sending text chunk (caption): {e}")
-                        return False
-            return True
+                logger.warning(f"[WhatsJet] Multipart upload failed, trying base64 method: {e}")
+                
+                # Try method 2: Send as base64 encoded content
+                try:
+                    media_b64 = base64.b64encode(media_content).decode('utf-8')
+                    payload = {
+                        "phone_number": phone_number,
+                        "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 'image.jpg',
+                        "message_body": ""  # No caption
+                    }
+                    
+                    logger.info(f"[WhatsJet] Attempting base64 upload for {phone_number}")
+                    response = httpx.post(
+                        url,
+                        json=payload,
+                        timeout=30
+                    )
+                    response.raise_for_status()
+                    logger.info(f"[WhatsJet] Media image sent successfully via base64 to {phone_number}")
+                    
+                    # Send caption as separate text message
+                    if message.strip():
+                        for chunk in split_message_for_whatsapp(message):
+                            try:
+                                text_payload = {"phone_number": phone_number, "message_body": chunk}
+                                text_response = httpx.post(
+                                    url,
+                                    json=text_payload,
+                                    timeout=15
+                                )
+                                text_response.raise_for_status()
+                                logger.info(f"[WhatsJet] Text chunk (caption) sent successfully to {phone_number}")
+                            except Exception as e:
+                                logger.error(f"[WhatsJet] Exception sending text chunk (caption): {e}")
+                                return False
+                    return True
+                    
+                except Exception as e:
+                    logger.error(f"[WhatsJet] Base64 method also failed: {e}")
+                    # Fallback: send text only
+                    logger.warning(f"[WhatsJet] Both image methods failed, sending text only for {phone_number}")
+                    return send_whatsjet_message(phone_number, message)
+                    
         except Exception as e:
             logger.error(f"[WhatsJet] Exception preparing media image: {str(e)}")
-            return False
+            # Fallback: send text only
+            return send_whatsjet_message(phone_number, message)
 
     # Handle other media messages (existing logic)
     if media_type and media_path:
@@ -960,26 +1030,50 @@ def send_whatsjet_message(phone_number: str, message: str, media_type: str = Non
             else:
                 with open(media_path, 'rb') as f:
                     media_content = f.read()
-            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'
-            }
+            
+            # Try multipart first, then base64
             try:
+                files = {
+                    'media': (filename or 'file.bin', media_content, media_type)
+                }
+                data = {
+                    'phone_number': phone_number,
+                    'message_body': message
+                }
+                
                 response = httpx.post(
                     url,
-                    json=payload,
-                    timeout=15
+                    data=data,
+                    files=files,
+                    timeout=30
                 )
                 response.raise_for_status()
-                logger.info(f"[WhatsJet] Media message sent successfully to {phone_number}")
+                logger.info(f"[WhatsJet] Media message sent successfully via multipart to {phone_number}")
                 return True
+                
             except Exception as e:
-                logger.error(f"[WhatsJet] Exception sending media message: {e}")
-                return False
+                logger.warning(f"[WhatsJet] Multipart upload failed for media, trying base64: {e}")
+                
+                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'
+                }
+                try:
+                    response = httpx.post(
+                        url,
+                        json=payload,
+                        timeout=30
+                    )
+                    response.raise_for_status()
+                    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}")
+                    return False
         except Exception as e:
             logger.error(f"[WhatsJet] Exception preparing media message: {str(e)}")
             return False
@@ -3637,11 +3731,15 @@ async def send_product_image_with_caption(from_number: str, product: Dict[str, A
     details = generate_veterinary_product_response(product, user_context)
     image_url = product.get('Images', '').strip() if 'Images' in product else ''
     
+    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:
@@ -3650,27 +3748,61 @@ 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}"
+                    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"
             
-            # Send using public URL (not local file)
-            success = send_whatsjet_message(
-                from_number,
-                details,
-                media_type=media_type,
-                media_path=image_url,  # Use public URL directly
-                filename=filename
-            )
+            # 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
             
-            if success:
-                logger.info(f"[Product] Sent image from CSV link with caption for product: {product_name}")
-                return
-            else:
-                logger.warning(f"[Product] Failed to send image from CSV link, trying fallback: {product_name}")
+            # 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=image_url,  # Use public URL directly
+                    filename=filename
+                )
+                
+                if success:
+                    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, trying fallback: {product_name}")
         
-        # Fallback to local uploads directory (public URL)
+        # 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 (image_path.startswith('http') or os.path.exists(image_path)):
             media_type = get_product_image_media_type(image_path)
@@ -3679,9 +3811,11 @@ async def send_product_image_with_caption(from_number: str, product: Dict[str, A
             # 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,
@@ -3692,17 +3826,18 @@ async def send_product_image_with_caption(from_number: str, product: Dict[str, A
             )
             
             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)
 
 @app.get("/test-product-image-with-caption")
@@ -3723,6 +3858,97 @@ 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()}
+
 if __name__ == "__main__":
     # Launch FastAPI app
     import uvicorn