Update app.py

app.py

@@ -888,154 +888,66 @@ 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. For images, send the image as a media message (no caption), then send the caption as a separate text message."""
+    """Send a message using WhatsJet API with optional media attachment"""
     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}"
 
-    # 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:
+    # Handle media messages
+    if media_type and media_path:
         try:
-            # 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"
+            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": "image",
-                "media_url": image_url,
-                "caption": message,
-                "file_name": filename or "image.jpg"
+                "phone_number": phone_number, 
+                "message_body": message,
+                'media_type': media_type,
+                'media_content': media_b64,
+                'media_filename': filename or os.path.basename(media_path)
             }
-            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
+            # Send message with increased timeout
             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=30
+                    timeout=15
                 )
-                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 via base64 to {phone_number}")
+                logger.info(f"[WhatsJet] Media message sent successfully to {phone_number}")
                 return True
             except Exception as e:
-                import traceback
-                logger.error(f"[WhatsJet][ERROR] Exception sending media message: {e}\nTraceback: {traceback.format_exc()}")
+                logger.error(f"[WhatsJet] Exception sending media message: {e}")
                 return False
         except Exception as e:
-            import traceback
-            logger.error(f"[WhatsJet][ERROR] Exception preparing media message: {str(e)}\nTraceback: {traceback.format_exc()}")
+            logger.error(f"[WhatsJet] Exception preparing media message: {str(e)}")
             return False
 
-    # Handle text messages (existing logic)
+    # Handle text messages
     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}
-            # 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}")
+            # 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
         except Exception as e:
-            import traceback
-            logger.error(f"[WhatsJet][ERROR] Exception sending text chunk: {e}\nTraceback: {traceback.format_exc()}")
+            logger.error(f"[WhatsJet] Exception preparing text chunk: {str(e)}")
             return False
+    
     logger.info(f"[WhatsJet] Successfully sent complete text message to {phone_number}")
     return True
 
@@ -3454,38 +3366,35 @@ load_products_data()
 
 def get_product_image_path(product_name: str) -> str:
     """
-    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.
+    Get the image path for a product
+    Returns the path to the product image if it exists, otherwise None
     """
     try:
-        # 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)
+        # Create images directory if it doesn't exist
         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
@@ -3667,20 +3576,11 @@ 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 ''
-    
-    # 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}")
-    
+    temp_file_path = None
     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:
@@ -3689,97 +3589,58 @@ 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"
-            
-            # 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}")
+            # 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"
                 success = send_whatsjet_message(
                     from_number,
                     details,
                     media_type=media_type,
-                    media_path=image_url,  # Use public URL directly
+                    media_path=temp_file_path,
                     filename=filename
                 )
-                
                 if success:
-                    logger.info(f"[Product] Successfully sent image from CSV link with caption for product: {product_name}")
+                    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}")
-        
-        # 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}")
+                    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
         image_path = get_product_image_path(product_name)
-        if image_path and (image_path.startswith('http') or os.path.exists(image_path)):
+        if image_path and 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=media_path,  # Use public URL
+                media_path=image_path,
                 filename=filename
             )
-            
             if success:
-                logger.info(f"[Product] Successfully sent image with caption for product: {product_name}")
+                logger.info(f"[Product] 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):
@@ -3799,201 +3660,6 @@ 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