fyp

app/ai/agent/nodes/listing_publish.py

@@ -302,12 +302,53 @@ async def listing_publish_handler(state: AgentState) -> AgentState:
         # ============================================================
         # STEP 4: Generate success message & UI Update
         # ============================================================
-        
+
         # Re-build UI for the published state
         from app.ai.agent.nodes.listing_validate import build_draft_ui
         draft_ui = build_draft_ui(draft)
         draft_ui["status"] = "published"
         draft_ui["title"] = f"✅ {draft.title}" # Add checkmark to title
+        draft_ui["listing_id"] = listing_id  # Include the new listing ID
+
+        # ✅ STEP 4.1: Enrich with owner rating/reviews for proper display
+        # Fetch owner's rating and reviews_count so the listing card shows correct data
+        try:
+            owner = await db.users.find_one({"_id": ObjectId(draft.user_id)})
+            if owner:
+                listing_type = draft.listing_type
+
+                # Owner info
+                first_name = owner.get("firstName", "")
+                last_name = owner.get("lastName", "")
+                draft_ui["owner_name"] = f"{first_name} {last_name}".strip() or "Unknown"
+                draft_ui["owner_profile_picture"] = owner.get("profilePicture")
+                draft_ui["user_id"] = draft.user_id
+
+                # Rating - for short-stay use listing's own rating (new listing = 0)
+                # For other types, use owner's rating
+                if listing_type == "short-stay":
+                    draft_ui["rating"] = 0.0  # New listing has no reviews yet
+                    draft_ui["reviews_count"] = 0
+                else:
+                    # Use owner's rating for rent/sale/roommate listings
+                    draft_ui["rating"] = owner.get("rating", 0.0)
+                    draft_ui["reviews_count"] = owner.get("reviews_count", 0)
+
+                logger.info(
+                    "Draft UI enriched with owner data",
+                    owner_name=draft_ui["owner_name"],
+                    rating=draft_ui["rating"],
+                    reviews_count=draft_ui["reviews_count"]
+                )
+            else:
+                # Fallback if owner not found
+                draft_ui["owner_name"] = "Unknown"
+                draft_ui["rating"] = 0.0
+                draft_ui["reviews_count"] = 0
+        except Exception as enrich_err:
+            logger.warning("Failed to enrich draft_ui with owner data", error=str(enrich_err))
+            draft_ui["rating"] = 0.0
+            draft_ui["reviews_count"] = 0
         
         # Generate personalized success message using LLM
         from langchain_openai import ChatOpenAI

app/models/user.py

@@ -51,7 +51,8 @@ class User:
             "languages": [],
             "preferredLanguage": preferred_language,  # User's preferred language for emails/notifications
             "isVerified": False,
-            "reviews_count": 0,
+            "rating": 0.0,  # User's average rating from reviews
+            "reviews_count": 0,  # Number of reviews received
             "lastLogin": None,
             "createdAt": now,
             "updatedAt": now,

app/services/listing_service.py

@@ -56,9 +56,14 @@ async def enrich_listing_with_owner_and_reviews(listing: dict, db) -> dict:
                 logger.debug(f"Short-stay listing {listing.get('_id')}: using listing rating")
             else:
                 # Use owner's rating (landlord/seller reviews)
-                listing["rating"] = owner.get("rating", 0.0)
-                listing["reviews_count"] = owner.get("reviews_count", 0)
-                logger.debug(f"Non-short-stay listing {listing.get('_id')}: using owner rating")
+                owner_rating = owner.get("rating", 0.0)
+                owner_reviews = owner.get("reviews_count", 0)
+                listing["rating"] = owner_rating
+                listing["reviews_count"] = owner_reviews
+                logger.info(
+                    f"Enriched listing {listing.get('_id')} ({listing_type}): "
+                    f"owner={user_id}, rating={owner_rating}, reviews={owner_reviews}"
+                )
         else:
             logger.warning(f"Owner {user_id} not found for listing {listing.get('_id')}")
             
@@ -126,8 +131,15 @@ async def enrich_listings_batch(listings: List[dict], db) -> List[dict]:
                     listing["rating"] = listing.get("rating", 0.0)
                     listing["reviews_count"] = listing.get("reviews_count", 0)
                 else:
-                    listing["rating"] = owner.get("rating", 0.0)
-                    listing["reviews_count"] = owner.get("reviews_count", 0)
+                    # Use owner's rating for non-short-stay listings
+                    owner_rating = owner.get("rating", 0.0)
+                    owner_reviews = owner.get("reviews_count", 0)
+                    listing["rating"] = owner_rating
+                    listing["reviews_count"] = owner_reviews
+                    logger.debug(
+                        f"Batch enrich: listing {listing.get('_id')} "
+                        f"owner={user_id}, rating={owner_rating}, reviews={owner_reviews}"
+                    )
         except Exception as e:
             logger.warning(f"Failed to enrich listing {listing.get('_id')} specific data: {e}")
         

scripts/fix_ratings.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""
+Migration Script: Fix Ratings and Reviews Count
+
+This script ensures all listings and users have correct rating/reviews_count:
+1. Users: Recalculates rating and reviews_count from actual reviews
+2. Short-stay listings: Recalculates rating and reviews_count from actual reviews
+3. Non-short-stay listings: Will use owner's rating (handled at fetch time)
+
+Run with: python scripts/fix_ratings.py
+"""
+
+import asyncio
+import sys
+import os
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from motor.motor_asyncio import AsyncIOMotorClient
+from bson import ObjectId
+from datetime import datetime
+
+# Import app config to get correct MongoDB URL
+from app.config import settings
+
+
+async def get_database():
+    """Connect to MongoDB using app settings"""
+    client = AsyncIOMotorClient(
+        settings.MONGODB_URL,
+        serverSelectionTimeoutMS=5000,
+    )
+    # Test connection
+    await client.admin.command("ping")
+    print(f"  📦 Database: {settings.MONGODB_DATABASE}")
+    return client[settings.MONGODB_DATABASE]
+
+
+async def recalculate_user_ratings(db):
+    """
+    Recalculate rating and reviews_count for all users
+    based on actual reviews in the reviews collection.
+    """
+    print("\n" + "="*60)
+    print("STEP 2: Recalculating User Ratings")
+    print("="*60)
+
+    # Get all users
+    users_cursor = db.users.find({})
+    users = await users_cursor.to_list(length=None)
+    print(f"Found {len(users)} users to process")
+
+    updated_count = 0
+
+    for user in users:
+        user_id = str(user["_id"])
+
+        # Find all reviews where this user is the target
+        reviews_cursor = db.reviews.find({
+            "target_type": "user",
+            "target_id": user_id
+        })
+        reviews = await reviews_cursor.to_list(length=None)
+
+        # Calculate new rating
+        if reviews:
+            total_rating = sum(r.get("rating", 0) for r in reviews)
+            reviews_count = len(reviews)
+            avg_rating = round(total_rating / reviews_count, 2)
+        else:
+            reviews_count = 0
+            avg_rating = 0.0
+
+        # Get current values
+        current_rating = user.get("rating", 0.0)
+        current_count = user.get("reviews_count", 0)
+
+        # Update if different or missing
+        if current_rating != avg_rating or current_count != reviews_count:
+            await db.users.update_one(
+                {"_id": user["_id"]},
+                {"$set": {
+                    "rating": avg_rating,
+                    "reviews_count": reviews_count
+                }}
+            )
+            updated_count += 1
+            print(f"  ✅ User {user.get('firstName', 'Unknown')} {user.get('lastName', '')}: "
+                  f"{current_rating} → {avg_rating} ({reviews_count} reviews)")
+
+    print(f"\n📊 Updated {updated_count} users")
+    return updated_count
+
+
+async def recalculate_listing_ratings(db):
+    """
+    Recalculate rating and reviews_count for all SHORT-STAY listings
+    based on actual reviews in the reviews collection.
+
+    Non-short-stay listings use the owner's rating (handled at fetch time).
+    """
+    print("\n" + "="*60)
+    print("STEP 3: Recalculating Short-Stay Listing Ratings")
+    print("="*60)
+
+    # Get all short-stay listings
+    listings_cursor = db.listings.find({"listing_type": "short-stay"})
+    listings = await listings_cursor.to_list(length=None)
+    print(f"Found {len(listings)} short-stay listings to process")
+
+    updated_count = 0
+
+    for listing in listings:
+        listing_id = str(listing["_id"])
+
+        # Find all reviews where this listing is the target
+        reviews_cursor = db.reviews.find({
+            "target_type": "listing",
+            "target_id": listing_id
+        })
+        reviews = await reviews_cursor.to_list(length=None)
+
+        # Calculate new rating
+        if reviews:
+            total_rating = sum(r.get("rating", 0) for r in reviews)
+            reviews_count = len(reviews)
+            avg_rating = round(total_rating / reviews_count, 2)
+        else:
+            reviews_count = 0
+            avg_rating = 0.0
+
+        # Get current values
+        current_rating = listing.get("rating", 0.0)
+        current_count = listing.get("reviews_count", 0)
+
+        # Update if different or missing
+        if current_rating != avg_rating or current_count != reviews_count:
+            await db.listings.update_one(
+                {"_id": listing["_id"]},
+                {"$set": {
+                    "rating": avg_rating,
+                    "reviews_count": reviews_count
+                }}
+            )
+            updated_count += 1
+            print(f"  ✅ Listing '{listing.get('title', 'Untitled')[:40]}': "
+                  f"{current_rating} → {avg_rating} ({reviews_count} reviews)")
+
+    print(f"\n📊 Updated {updated_count} short-stay listings")
+    return updated_count
+
+
+async def ensure_fields_exist(db):
+    """
+    Ensure all users and listings have the rating/reviews_count fields.
+    This initializes them to 0 if missing.
+    """
+    print("\n" + "="*60)
+    print("STEP 1: Ensuring Fields Exist on All Documents")
+    print("="*60)
+
+    # Update users missing rating field
+    users_result = await db.users.update_many(
+        {"rating": {"$exists": False}},
+        {"$set": {"rating": 0.0}}
+    )
+    print(f"  ✅ Added 'rating' field to {users_result.modified_count} users")
+
+    # Update users missing reviews_count field
+    users_result2 = await db.users.update_many(
+        {"reviews_count": {"$exists": False}},
+        {"$set": {"reviews_count": 0}}
+    )
+    print(f"  ✅ Added 'reviews_count' field to {users_result2.modified_count} users")
+
+    # Update short-stay listings missing rating field
+    listings_result = await db.listings.update_many(
+        {"listing_type": "short-stay", "rating": {"$exists": False}},
+        {"$set": {"rating": 0.0}}
+    )
+    print(f"  ✅ Added 'rating' field to {listings_result.modified_count} short-stay listings")
+
+    # Update short-stay listings missing reviews_count field
+    listings_result2 = await db.listings.update_many(
+        {"listing_type": "short-stay", "reviews_count": {"$exists": False}},
+        {"$set": {"reviews_count": 0}}
+    )
+    print(f"  ✅ Added 'reviews_count' field to {listings_result2.modified_count} short-stay listings")
+
+
+async def print_summary(db):
+    """Print a summary of the current state"""
+    print("\n" + "="*60)
+    print("SUMMARY")
+    print("="*60)
+
+    # Count users with reviews
+    users_with_reviews = await db.users.count_documents({"reviews_count": {"$gt": 0}})
+    total_users = await db.users.count_documents({})
+    print(f"  👥 Users with reviews: {users_with_reviews}/{total_users}")
+
+    # Count listings by type
+    for listing_type in ["rent", "sale", "short-stay", "roommate"]:
+        count = await db.listings.count_documents({"listing_type": listing_type})
+        if listing_type == "short-stay":
+            with_reviews = await db.listings.count_documents({
+                "listing_type": listing_type,
+                "reviews_count": {"$gt": 0}
+            })
+            print(f"  🏠 {listing_type}: {count} listings ({with_reviews} with reviews)")
+        else:
+            print(f"  🏠 {listing_type}: {count} listings (use owner's rating)")
+
+    # Count total reviews
+    total_reviews = await db.reviews.count_documents({})
+    user_reviews = await db.reviews.count_documents({"target_type": "user"})
+    listing_reviews = await db.reviews.count_documents({"target_type": "listing"})
+    print(f"\n  ⭐ Total reviews: {total_reviews}")
+    print(f"     - User reviews (for landlords): {user_reviews}")
+    print(f"     - Listing reviews (for properties): {listing_reviews}")
+
+
+async def main():
+    """Main migration function"""
+    print("\n" + "="*60)
+    print("🔧 RATING MIGRATION SCRIPT")
+    print("="*60)
+    print(f"Started at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+
+    try:
+        db = await get_database()
+        print(f"✅ Connected to MongoDB successfully")
+
+        # Step 1: Ensure all fields exist
+        await ensure_fields_exist(db)
+
+        # Step 2: Recalculate user ratings
+        await recalculate_user_ratings(db)
+
+        # Step 3: Recalculate short-stay listing ratings
+        await recalculate_listing_ratings(db)
+
+        # Print summary
+        await print_summary(db)
+
+        print("\n" + "="*60)
+        print("✅ MIGRATION COMPLETED SUCCESSFULLY")
+        print("="*60)
+        print(f"Finished at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+
+    except Exception as e:
+        print(f"\n❌ ERROR: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())