Add property search functionality and related database queries

- Implemented `handle_property_search` to detect property search intent and return relevant property suggestions.
- Enhanced `process_message` to trigger property search based on user input or persona location preference.
- Added new database functions: `search_properties`, `get_property_by_id`, and `get_available_cities` for property management.
- Improved user experience by providing fallback messages when no properties are found, along with a list of available cities.

ai_chat.py

@@ -2,7 +2,7 @@ from langgraph.graph import StateGraph, END
 from langchain_core.runnables import RunnableLambda
 from typing import TypedDict
 from config import llm, OPENAI_API_KEY
-from database import get_session_messages, save_message
+from database import get_session_messages, save_message, search_properties, get_available_cities
 from persona_manager import (
     get_or_create_persona, 
     should_ask_persona_question, 
@@ -12,6 +12,7 @@ from persona_manager import (
     get_persona_summary,
     extract_persona_from_message
 )
+import re
 
 def chat_with_session_memory(state):
     """Chat function with session-based memory and persona collection"""
@@ -183,6 +184,48 @@ graph.set_entry_point("chat")
 graph.add_edge("chat", END)
 chat_graph = graph.compile()
 
+async def handle_property_search(user_message, persona):
+    """Detects property search intent and returns property suggestions or fallback message."""
+    # Extract city from persona or user message
+    city = None
+    if persona.get("location_preference"):
+        city = persona["location_preference"]
+    else:
+        # Try to extract city from message (very basic, can be improved)
+        match = re.search(r"in ([a-zA-Z ]+)", user_message, re.IGNORECASE)
+        if match:
+            city = match.group(1).strip()
+    
+    # Optionally extract size, price, features from persona
+    min_size = persona.get("size_preference_sqm")
+    features = persona.get("must_have")
+    price_type = None
+    if persona.get("intent") in ["lease", "rent"]:
+        price_type = "lease"
+    elif persona.get("intent") == "buy":
+        price_type = "sale"
+    
+    # Search properties
+    properties = await search_properties(city=city, min_size=min_size, features=features, price_type=price_type, limit=5)
+    if properties:
+        messages = []
+        for prop in properties:
+            msg = f"🏢 *{prop['title']}*\n{prop['description']}\n\n*Location:* {prop['address']} ({prop['city']}, {prop['province']})\n*Size:* {prop['size_sqm']} sqm\n*Price:* R{int(prop['price']):,} per month\n*Type:* {prop['price_type'].capitalize()}\n*Features:* {', '.join(prop['features']) if prop.get('features') else 'N/A'}\n\n[View Listing]({prop['listing_url']})"
+            messages.append(msg)
+        # Add follow-up question about images
+        messages.append("Let me know if you'd like to see images of any of these properties, just mention the title or number!")
+        return messages
+    else:
+        # No results, apologize and list available cities
+        available_cities = await get_available_cities()
+        if city:
+            msg = f"Sorry, we currently have no properties available in {city.title()}."
+        else:
+            msg = "Sorry, we couldn't find any properties matching your search."
+        if available_cities:
+            msg += f"\n\nWe do have properties in: {', '.join(available_cities)}."
+        return [msg]
+
 async def process_message(user_message: str, user_info: dict = None, session_id: str = None, wa_id: str = None, wamid: str = None):
     """Process a message through the AI chat system with session memory and persona collection"""
     if user_info is None:
@@ -234,6 +277,19 @@ async def process_message(user_message: str, user_info: dict = None, session_id:
         conversation_context = " ".join([msg["content"] for msg in session_messages[-5:]]) + " " + user_message
         should_ask, field_to_ask = await should_ask_persona_question(updated_persona, conversation_context)
     
+    # Check for property search intent
+    property_search_phrases = [
+        "show me properties", "property in", "warehouse in", "industrial in", "listings in", "toon my eiendomme", "warehouse", "factory", "show me warehouses", "show me listings"
+    ]
+    is_property_search = any(phrase in user_message.lower() for phrase in property_search_phrases)
+    if persona.get("location_preference") or is_property_search:
+        property_msgs = await handle_property_search(user_message, updated_persona)
+        for msg in property_msgs:
+            # Send each property message (simulate WhatsApp message send)
+            print(f"Property suggestion: {msg}")
+        # If property suggestions were sent, return the first as the AI response (rest will be sent as follow-ups)
+        return property_msgs[0] if property_msgs else "Let me know if you'd like to see images or more details!"
+    
     # Process with AI
     result = await chat_graph.ainvoke({
         "user_message": user_message,

database.py

@@ -181,4 +181,71 @@ async def update_user_name(wa_id: str, name: str):
         return response.data[0] if response.data else None
     except Exception as e:
         print(f"Error updating user: {e}")
-        return None 
+        return None 
+
+# --- Property Listings ---
+async def search_properties(
+    city: str = None,
+    min_size: int = None,
+    max_size: int = None,
+    min_price: float = None,
+    max_price: float = None,
+    features: list = None,
+    price_type: str = None,
+    limit: int = 10,
+    offset: int = 0
+) -> list:
+    """Search properties with flexible filters. Only returns active listings."""
+    if not supabase:
+        return []
+    try:
+        query = supabase.table("properties").select("*").eq("is_active", True)
+        if city:
+            query = query.ilike("city", f"%{city}%")
+        if min_size:
+            query = query.gte("size_sqm", min_size)
+        if max_size:
+            query = query.lte("size_sqm", max_size)
+        if min_price:
+            query = query.gte("price", min_price)
+        if max_price:
+            query = query.lte("price", max_price)
+        if price_type:
+            query = query.eq("price_type", price_type)
+        if features:
+            for feature in features:
+                query = query.contains("features", [feature])
+        query = query.range(offset, offset + limit - 1)
+        query = query.order("is_featured", desc=True).order("updated_at", desc=True)
+        resp = query.execute()
+        return resp.data if resp.data else []
+    except Exception as e:
+        print(f"Error searching properties: {e}")
+        return []
+
+async def get_property_by_id(property_id: str) -> dict:
+    """Get a property by its ID."""
+    if not supabase:
+        return None
+    try:
+        resp = supabase.table("properties").select("*").eq("id", property_id).single().execute()
+        return resp.data if resp.data else None
+    except Exception as e:
+        print(f"Error getting property by id: {e}")
+        return None
+
+async def get_available_cities() -> list:
+    """Get a list of all cities with active properties."""
+    if not supabase:
+        return []
+    try:
+        resp = supabase.table("properties").select("city").eq("is_active", True).execute()
+        cities = set()
+        if resp.data:
+            for row in resp.data:
+                if row.get("city"):
+                    cities.add(row["city"].strip())
+        return sorted(list(cities))
+    except Exception as e:
+        print(f"Error getting available cities: {e}")
+        return []