Properties API¶

# Get all properties
properties = client.properties.list_properties()
print(f"Found {len(properties)} properties")

# Display basic info
for prop in properties:
    print(f"Property {prop['id']}: {prop.get('address', 'No address')}")

# Get active properties in New York
active_ny_properties = client.properties.list_properties(params={
    "status": "Active",
    "state": "NY",
    "limit": 25
})

# Get recently created properties
recent_properties = client.properties.list_properties(params={
    "sort": "-created_at",
    "limit": 10
})

# Paginate through all properties
all_properties = []
offset = 0
limit = 100

while True:
    batch = client.properties.list_properties(params={
        "limit": limit,
        "offset": offset
    })

    if not batch:
        break

    all_properties.extend(batch)
    offset += limit

print(f"Total properties: {len(all_properties)}")

# ✨ NEW: Preserve text for proper UI display and recognition
property1 = client.properties.create_property({
    "title": "Beautiful Family Home",
    "client_type": "Buyer",           # ← Stays as "Buyer" in UI
    "status": "Under Contract"        # ← Stays as "Under Contract" in UI
}, preserve_text_values=True)

# ✅ IMPORTANT: Use proper title case for UI recognition
property2 = client.properties.create_property({
    "title": "Downtown Luxury Condo",
    "client_type": "Seller",          # ← Title case required
    "status": "Listing- Active",      # ← Title case required
    "purchase_amount": 525000
}, preserve_text_values=True)

# Compare: Default behavior vs. preserve_text_values
print("=== Comparison ===")

# Default: Converts to IDs (backwards compatible)
default_property = client.properties.create_property({
    "title": "Test Property",
    "client_type": "buyer",           # → Becomes 797212
    "status": "under contract"        # → Becomes 797209
})

# Preserve: Keeps text (UI-friendly)
preserve_property = client.properties.create_property({
    "title": "Test Property",
    "client_type": "Buyer",           # → Stays "Buyer"
    "status": "Under Contract"        # → Stays "Under Contract"
}, preserve_text_values=True)

# 1. Just a title (uses smart defaults)
property1 = client.properties.create_property("Beautiful Family Home")

# 2. Simple dictionary with common fields
property2 = client.properties.create_property({
    "title": "Downtown Luxury Condo",
    "client_type": "Buyer",
    "status": "Active", 
    "purchase_amount": 525000
})

# 3. Seller listing
property3 = client.properties.create_property({
    "title": "Suburban Family Home",
    "client_type": "Seller",
    "status": "Pre-MLS",
    "purchase_amount": 675000
})

print(f"Created property: {property2['id']}")

# Traditional comprehensive format (still works)
property_data = {
    "address": "789 Pine Street",
    "city": "Chicago",
    "state": "IL",
    "zip_code": "60601",
    "property_type": "Condo",
    "bedrooms": 2,
    "bathrooms": 2,
    "square_feet": 1200,
    "listing_price": 350000,
    "status": "Coming Soon",
    "description": "Beautiful downtown condo with city views",
    "year_built": 2015,
    "parking_spaces": 1,
    "hoa_fee": 150
}

new_property = client.properties.create_property(property_data)
print(f"Created {new_property['property_type']} at {new_property['address']}")

# The API provides clear validation errors
try:
    property = client.properties.create_property({
        "title": "Test Property",
        "client_type": "InvalidType"  # ❌ Will fail with clear message
    })
except ValidationError as e:
    print(f"Validation error: {e}")
    # Output: Invalid client_type: InvalidType. Must be one of: buyer, seller, dual

# Pre-validate data before creation
data = {"title": "Test", "client_type": "Buyer"}
is_valid, errors = client.validate_property_data(data)
if is_valid:
    property = client.properties.create_property(data)
else:
    print(f"Validation errors: {errors}")

# Get a specific property
property_data = client.properties.retrieve_property(123)

print(f"Property: {property_data['address']}")
print(f"Status: {property_data.get('status', 'Unknown')}")
print(f"Price: ${property_data.get('listing_price', 0):,}")

# Display comprehensive property information
property_data = client.properties.retrieve_property(123)

print("=== Property Details ===")
print(f"ID: {property_data['id']}")
print(f"Address: {property_data.get('address', 'Not specified')}")
print(f"City: {property_data.get('city', 'Not specified')}")
print(f"State: {property_data.get('state', 'Not specified')}")
print(f"Type: {property_data.get('property_type', 'Not specified')}")
print(f"Bedrooms: {property_data.get('bedrooms', 'Not specified')}")
print(f"Bathrooms: {property_data.get('bathrooms', 'Not specified')}")
print(f"Square Feet: {property_data.get('square_feet', 'Not specified')}")
print(f"Status: {property_data.get('status', 'Unknown')}")

if property_data.get('listing_price'):
    print(f"Price: ${property_data['listing_price']:,}")

from open_to_close.exceptions import NotFoundError

def safe_get_property(property_id):
    try:
        property_data = client.properties.retrieve_property(property_id)
        return property_data
    except NotFoundError:
        print(f"Property {property_id} not found")
        return None
    except Exception as e:
        print(f"Error retrieving property {property_id}: {e}")
        return None

# Usage
property_data = safe_get_property(123)
if property_data:
    print(f"Found property: {property_data['address']}")

# Update property status
updated_property = client.properties.update_property(123, {
    "status": "Under Contract"
})

# Update pricing
updated_property = client.properties.update_property(123, {
    "listing_price": 375000,
    "price_reduction": True
})

print(f"Updated property {updated_property['id']}")

# Mark property as sold
def mark_property_sold(property_id, sale_price, closing_date):
    return client.properties.update_property(property_id, {
        "status": "Sold",
        "sale_price": sale_price,
        "closing_date": closing_date,
        "days_on_market": calculate_days_on_market(property_id)
    })

# Mark as contingent
def mark_property_contingent(property_id, offer_price):
    return client.properties.update_property(property_id, {
        "status": "Contingent",
        "offer_price": offer_price,
        "contingent_date": datetime.now().isoformat()
    })

# Usage
sold_property = mark_property_sold(123, 365000, "2024-02-15")

# Update multiple fields at once
comprehensive_update = client.properties.update_property(123, {
    "status": "Active",
    "listing_price": 425000,
    "description": "Price reduced! Beautiful home with updates.",
    "marketing_remarks": "New price reflects motivated seller",
    "virtual_tour_url": "https://tour.example.com/property123",
    "photos_updated": True,
    "last_modified": datetime.now().isoformat()
})

# Delete a property
result = client.properties.delete_property(123)
print("Property deleted successfully")

def safe_delete_property(property_id, confirm=False):
    """Safely delete a property with confirmation."""
    if not confirm:
        print("This will permanently delete the property.")
        print("Call with confirm=True to proceed.")
        return None

    try:
        # Check if property has related records
        contacts = client.property_contacts.list_property_contacts(property_id)
        tasks = client.property_tasks.list_property_tasks(property_id)

        if contacts or tasks:
            print(f"Warning: Property has {len(contacts)} contacts and {len(tasks)} tasks")
            print("Consider cleaning up related data first.")

        result = client.properties.delete_property(property_id)
        print(f"Property {property_id} deleted successfully")
        return result

    except Exception as e:
        print(f"Error deleting property {property_id}: {e}")
        return None

# Usage
safe_delete_property(123, confirm=True)

# Instead of deleting, mark as archived
def archive_property(property_id):
    """Archive a property instead of deleting it."""
    return client.properties.update_property(property_id, {
        "status": "Archived",
        "archived_date": datetime.now().isoformat(),
        "active": False
    })

# Usage
archived_property = archive_property(123)
print(f"Property {archived_property['id']} archived")