Upload 6 files

app/crud.py

@@ -5,10 +5,10 @@ from utils.log_utils import setup_logger
 
 logger = setup_logger("crud")
 
-def get_property_by_mls_and_buyer_phone(db: Session, mls_number: str, buyer_agent_phone_number: str):
-    return db.query(models.Property).filter(
-        models.Property.mls_number == mls_number,
-        models.Property.buyer_agent_phone_number == buyer_agent_phone_number
+def get_booking_by_mls_and_buyer_phone(db: Session, mls_number: str, buyer_agent_phone_number: str):
+    return db.query(models.booking).filter(
+        models.booking.mls_number == mls_number,
+        models.booking.buyer_agent_phone_number == buyer_agent_phone_number
     ).first()
 
 def get_user_by_phone_number(db: Session, phone_number: str):
@@ -22,11 +22,12 @@ def create_user(db: Session, full_name: str, phone_number: str, type: str, agent
             user = db.query(models.User).filter(models.User.phone_number == phone_number).first()
             if user:
                 if user.active_session_id:
-                    logger.info(f"User Already exist, with phone_number: {phone_number}")
+                    user.queued_session_ids = user.queued_session_ids + [new_session_id]
+                    logger.info(f"The user already exists with the provided phone number and has an active session. Therefore, the task is being added to the queue: {phone_number}")
+                    return None
                 else:
-                    logger.info(f"User Already exist, with phone_number: {phone_number}")
+                    logger.info(f"The user already exists with the provided phone number : {phone_number}")
                     user.active_session_id = new_session_id
-                user.all_session_ids = user.all_session_ids + [new_session_id]
                 db.commit()
                 db.refresh(user)
                 return user
@@ -44,26 +45,31 @@ def create_user(db: Session, full_name: str, phone_number: str, type: str, agent
                 db.refresh(new_user)
                 return new_user
         else:
-            logger.info(f"Buyer Agent Found: Creating buyer agent with phone number: {phone_number}")
-            new_user = models.User(full_name=full_name,
-                                    phone_number=phone_number,
-                                    type="buyer",
-                                    agent_id=agent_id,
-                                    broker_name=broker_name)
-            db.add(new_user)
-            db.commit()
-            db.refresh(new_user)
-            return new_user
+            user = db.query(models.User).filter(models.User.phone_number == phone_number).first()
+            if user:
+                logger.info(f"Buyer Agent Found: User already exist with phone number: {phone_number}")
+                return {"status": "exists", "message": "User already exists"}
+            else:
+                logger.info(f"Buyer Agent Found: Creating buyer agent with phone number: {phone_number}")
+                new_user = models.User(full_name=full_name,
+                                        phone_number=phone_number,
+                                        type="buyer",
+                                        agent_id=agent_id,
+                                        broker_name=broker_name)
+                db.add(new_user)
+                db.commit()
+                db.refresh(new_user)
+                return new_user
     except Exception as e:
         db.rollback()
-        print(f"Error creating user: {e}")
-        return None
+        logger.error(f"Error creating user: {e}")
+        return {"status": "error", "message": f"Error: {str(e)}"}
 
-def get_property_by_session_id(db: Session, session_id: str):
-    return db.query(models.Property).filter(models.Property.listing_agent_session_id == session_id).first()
+def get_booking_by_session_id(db: Session, session_id: str):
+    return db.query(models.booking).filter(models.booking.listing_agent_session_id == session_id).first()
 
 
-def create_property(db: Session,
+def create_booking(db: Session,
                     buyer_agent_phone_number: str,
                     address: str, mls_number: str,
                     buyer_selected_date: str,
@@ -74,18 +80,18 @@ def create_property(db: Session,
                     listing_agent_session_id: str = None,
                     status: str = None):
     try:
-        property = db.query(models.Property).filter(models.Property.mls_number == mls_number,
-                                                    models.Property.buyer_agent_phone_number == buyer_agent_phone_number).first()
-        if property:
-            logger.info(f"Property already exist: Updating property with mls_number: {mls_number}")
-            property.buyer_selected_date = buyer_selected_date
-            property.buyer_selected_time = buyer_selected_time
+        booking = db.query(models.booking).filter(models.booking.mls_number == mls_number,
+                                                    models.booking.buyer_agent_phone_number == buyer_agent_phone_number).first()
+        if booking:
+            logger.info(f"booking already exist: Updating booking with mls_number: {mls_number}")
+            booking.buyer_selected_date = buyer_selected_date
+            booking.buyer_selected_time = buyer_selected_time
             db.commit()
-            db.refresh(property)
-            return property
+            db.refresh(booking)
+            return booking
         else:
-            logger.info(f"Creating new property with mls_number: {mls_number}")
-            new_property = models.Property(buyer_agent_phone_number=buyer_agent_phone_number,
+            logger.info(f"Creating new booking with mls_number: {mls_number}")
+            new_booking = models.booking(buyer_agent_phone_number=buyer_agent_phone_number,
                                         address=address,
                                         mls_number=mls_number,
                                         buyer_selected_date=buyer_selected_date,
@@ -95,11 +101,11 @@ def create_property(db: Session,
                                         listing_agent_phone_number=listing_agent_phone_number,
                                         listing_agent_session_id=listing_agent_session_id,
                                         status=status)
-            db.add(new_property)
+            db.add(new_booking)
             db.commit()
-            db.refresh(new_property)
-            return new_property
+            db.refresh(new_booking)
+            return new_booking
     except Exception as e:
         db.rollback()
-        print(f"Error creating property: {e}")
+        print(f"Error creating booking: {e}")
         return None

app/models.py

@@ -12,13 +12,14 @@ class User(Base):
     type = Column(String, default="buyer")
     broker_name = Column(String, default="")
     active_session_id = Column(String, default="")
-    all_session_ids = Column(ARRAY(String), default=[])
+    queued_session_ids = Column(ARRAY(String), default=[])
+    completed_session_ids = Column(ARRAY(String), default=[])
     created_at = Column(DateTime(timezone=True), server_default=func.now())
 
-    properties = relationship("Property", back_populates="buyer_agent")
+    bookings = relationship("booking", back_populates="buyer_agent")
 
-class Property(Base):
-    __tablename__ = "properties"
+class booking(Base):
+    __tablename__ = "bookings"
 
     id = Column(Integer, primary_key=True, index=True)
     buyer_agent_phone_number = Column(String, ForeignKey("users.phone_number"), nullable=False)
@@ -33,4 +34,4 @@ class Property(Base):
     status = Column(String, default="pending")
     created_at = Column(DateTime(timezone=True), server_default=func.now())
 
-    buyer_agent = relationship("User", back_populates="properties")
+    buyer_agent = relationship("User", back_populates="bookings")

app/router.py

@@ -1,12 +1,13 @@
-
 from app import models, crud
-from app.database import SessionLocal, engine
-from utils.log_utils import setup_logger
-from fastapi import Request, Depends, APIRouter, HTTPException
 import os, json, random, requests
 from sqlalchemy.orm import Session
 from fastapi.responses import JSONResponse
+from app.database import SessionLocal, engine
+from utils.log_utils import setup_logger
+from fastapi import Request, Depends, APIRouter, HTTPException
 from twilio.twiml.messaging_response import MessagingResponse
+from app.services.properties import get_property_by_address_or_mls_number
+from app.services.agent import verify_agent_by_agent_id_and_broker_name
 from fastapi.responses import Response
 from pydantic import BaseModel, Field
 from twilio.rest import Client
@@ -32,6 +33,19 @@ def get_db():
     finally:
         db.close()
 
+
+@router.post('/realtor/get_properties')
+async def get_properties(address: str=None, mls_number: str=None, db: Session = Depends(get_db)):
+    logger.warning(f"get_properties request: address: {address}, mls_number: {mls_number}")
+    response = get_property_by_address_or_mls_number(mls_number=mls_number, address=address)
+    return JSONResponse(content=response)
+
+@router.post('/realtor/verify_agent')
+async def verify_agent(agent_id: str, broker_name: str, db: Session = Depends(get_db)):
+    logger.warning(f"verify_agent request: agent_id: {agent_id}, broker_name: {broker_name}")
+    return verify_agent_by_agent_id_and_broker_name(agent_id=agent_id, broker_name=broker_name)
+
+
 class MessageRequestSignUP(BaseModel):
     phone_number: str = Field(default="+917389058485")
     agent_id: str = Field(default="")
@@ -72,9 +86,9 @@ def create_payload_for_whatsapp_message(from_number, to_number, body):
     return payload
 
 
-class CreatePropertyRequest(BaseModel):
+class CreatebookingRequest(BaseModel):
     buyer_agent_phone_number: str = Field(default="+917389058485")
-    address: str = Field(default="property_address_test")
+    address: str = Field(default="booking_address_test")
     mls_number: str = Field(default="mls_number_test")
     buyer_selected_date: str = Field(default="date_test")
     buyer_selected_time: str = Field(default="time_test")
@@ -82,9 +96,9 @@ class CreatePropertyRequest(BaseModel):
     listing_agent_session_id: str = Field(default="")
     status: str = Field(default="pending")
 
-@router.post('/realtor/create_property')
-async def create_property(request: CreatePropertyRequest, db: Session = Depends(get_db)):
-    logger.warning(f"Create property request: {request}")
+@router.post('/realtor/create_booking')
+async def create_booking(request: CreatebookingRequest, db: Session = Depends(get_db)):
+    logger.warning(f"Create booking request: {request}")
 
     buyer_agent_phone_number = request.buyer_agent_phone_number
     address = request.address
@@ -96,19 +110,53 @@ async def create_property(request: CreatePropertyRequest, db: Session = Depends(
     status = request.status
 
     try:
-        property = crud.create_property(db, buyer_agent_phone_number=buyer_agent_phone_number,
+        booking = crud.create_booking(db, buyer_agent_phone_number=buyer_agent_phone_number,
                                             address=address, mls_number=mls_number, buyer_selected_date=buyer_selected_date,
                                             buyer_selected_time=buyer_selected_time, listing_agent_phone_number=listing_agent_phone_number,
                                             listing_agent_session_id=listing_agent_session_id, status=status)
     except Exception as e:
         db.rollback()
-        logger.error(f"Error in creating property: {e}")
-        raise HTTPException(status_code=400, detail="Property creation failed")
+        logger.error(f"Error in creating booking: {e}")
+        raise HTTPException(status_code=400, detail="booking creation failed")
+
+    return JSONResponse(content="booking is created successfully.")
+
+
+class BuyerRealtorSignUP(BaseModel):
+    full_name: str = Field(default="full_name_test")
+    agent_id: str = Field(default="agent_id_test")
+    broker_name: str = Field(default="broker_name_test")
+    phone_number: str = Field(default="")
+    type: str = Field(default="buyer")
+
+@router.post('/buyer_realtor/signup')
+async def buyer_realtor_sign_up(request: BuyerRealtorSignUP, db: Session = Depends(get_db)):
+    logger.warning(f"Buyer realtor singup request: {request}")
+    full_name = request.full_name
+    agent_id = request.agent_id
+    broker_name = request.broker_name
+    phone_number = request.phone_number
+    type = request.type
+    #TODO: Add logic to verify agent_id and broker_name
+    if not verify_agent_by_agent_id_and_broker_name(agent_id=agent_id, broker_name=broker_name):
+        raise HTTPException(status_code=400, detail="Invalid agent_id or broker_name")
+    user = crud.create_user(db, full_name=full_name, phone_number=phone_number, type=type, agent_id=agent_id, broker_name=broker_name)
+    logger.warning(f"User: {user}")
+    if isinstance(user, dict) and "status" in user:
+        logger.warning(f"User status: {user['status']}")
+        if user["status"] == "exists":
+            logger.info(f"User already exist with this phone number.")
+            raise HTTPException(status_code=400, detail="User already exist with this phone number.")
+        if user["status"] == "failed":
+            logger.error(f"Error in creating user.")
+            raise HTTPException(status_code=400, detail=str(user["message"]))
+    if not user:
+        raise HTTPException(status_code=400, detail="User creation failed")
+    return JSONResponse(content="user is signed up sucessfully.")
 
-    return JSONResponse(content="Property is created successfully.")
 
 class ListingRealtorSignUP(BaseModel):
-    property_address: str = Field(default="property_address_test")
+    booking_address: str = Field(default="booking_address_test")
     mls_number: str = Field(default="mls_number_test")
     date: str = Field(default="date_test")
     time: str = Field(default="time_test")
@@ -118,39 +166,39 @@ class ListingRealtorSignUP(BaseModel):
 async def listing_realtor_sign_up(request: ListingRealtorSignUP, db: Session = Depends(get_db)):
     logger.warning(f"Listing realtor singup request: {request}")
 
-    property_address = request.property_address
+    booking_address = request.booking_address
     mls_number = request.mls_number
     buyer_selected_date = request.date
     buyer_selected_time = request.time
     buyer_agent_phone_number = request.buyer_agent_phone_number
 
-    logger.warning(f"Listing realtore - property_address: {property_address}, mls_number: {mls_number}, date: {buyer_selected_date}, time: {buyer_selected_time}, buyer_agent_phone_number: {buyer_agent_phone_number}")
-    #TODO: Add logic to get property details from mls_number
-    listing_agent_full_name = "Bob"
-    listing_agent_phone_number = "+917347256305"
+    logger.warning(f"Listing realtore - booking_address: {booking_address}, mls_number: {mls_number}, date: {buyer_selected_date}, time: {buyer_selected_time}, buyer_agent_phone_number: {buyer_agent_phone_number}")
+    #TODO: Add logic to get booking details from mls_number
+    response = get_property_by_address_or_mls_number(mls_number=mls_number, address=booking_address)
+    if response["address"] != booking_address or response["mls_number"] != mls_number:
+        raise HTTPException(status_code=400, detail="Invalid mls_number or address")
+    listing_agent_full_name = response["agent_name"]
+    listing_agent_phone_number = response["agent_phone"]
     type = "listing"
-    property_address = "123 Main Street"
+    booking_address = response["address"]
     try:
         buyer_user = crud.get_user_by_phone_number(db, phone_number=buyer_agent_phone_number)
         if not buyer_user:
             raise HTTPException(status_code=400, detail="Buyer agent not found")
         listing_user = crud.create_user(db, full_name=listing_agent_full_name, phone_number=listing_agent_phone_number, type=type)
-    except Exception as e:
-        db.rollback()
-        logger.error(f"Error in creating user: {e}")
-        raise HTTPException(status_code=400, detail="User creation failed")
-
-    try:
-        property = crud.create_property(db, buyer_agent_phone_number=buyer_agent_phone_number,
-                                            address=property_address, mls_number=mls_number, buyer_selected_date=buyer_selected_date,
+        if not listing_user:
+            logger.info(f"Listing agent have already active session so putting the task in queue.")
+            return JSONResponse(content="I will let you know once the listing agent confirms the showing appointment.")
+        booking = crud.create_booking(db, buyer_agent_phone_number=buyer_agent_phone_number,
+                                            address=booking_address, mls_number=mls_number, buyer_selected_date=buyer_selected_date,
                                             buyer_selected_time=buyer_selected_time, listing_agent_phone_number=listing_agent_phone_number,
                                             listing_agent_session_id=listing_user.active_session_id)
     except Exception as e:
         db.rollback()
-        logger.error(f"Error in creating property: {e}")
-        raise HTTPException(status_code=400, detail="Property creation failed")
+        logger.error(f"Error in creating booking: {e}")
+        raise HTTPException(status_code=400, detail="booking creation failed")
 
-    listing_agent_body = f"Hello {listing_agent_full_name}, this is Alice assistant of {buyer_user.full_name}. We would like to schedule a showing for {property_address} (MLS # {mls_number}) at {buyer_selected_time} on {buyer_selected_date}. Can you make that work?"
+    listing_agent_body = f"Hello {listing_agent_full_name}, this is Alice assistant of {buyer_user.full_name}. We would like to schedule a showing for {booking_address} (MLS # {mls_number}) at {buyer_selected_time} on {buyer_selected_date}. Can you make that work?"
 
     try:
         logger.info(f"Sending message to listing agent from: {ai_agnet_number}, body: {listing_agent_body}, to: {listing_agent_phone_number}")
@@ -164,7 +212,8 @@ async def listing_realtor_sign_up(request: ListingRealtorSignUP, db: Session = D
         logger.error(f"Error in sending message to listing agent: {e}")
         raise HTTPException(status_code=400, detail=f"Error in sending message to listing agent: {e}")
 
-    return JSONResponse(content="I will inform you as soon as the listing agent confirms the property showing. The notification has been sent to them successfully.")
+    return JSONResponse(content="I will let you know once the listing agent confirms the showing appointment.")
+
 
 
 class ListingRealtorConfirmation(BaseModel):
@@ -183,37 +232,37 @@ async def listing_realtor_sign_up(request: ListingRealtorConfirmation, db: Sessi
 
     logger.warning(f"Listing realtore - listing_selected_date: {listing_selected_date}, listing_selected_time: {listing_selected_time}, session_id: {session_id}, confirmation: {confirmation}.")
     try:
-        property = crud.get_property_by_session_id(db, session_id=session_id)
-        listing_user = crud.get_user_by_phone_number(db, phone_number=property.listing_agent_phone_number)
+        booking = crud.get_booking_by_session_id(db, session_id=session_id)
+        listing_user = crud.get_user_by_phone_number(db, phone_number=booking.listing_agent_phone_number)
     except Exception as e:
         logger.error(f"Error in creating user: {e}")
-        raise HTTPException(status_code=400, detail=f"property not found with this session id, Error: {str(e)}")
-    if not property:
-        raise HTTPException(status_code=400, detail="property not found with this session id")
-    property.listing_selected_date = listing_selected_date
-    property.listing_selected_time = listing_selected_time
+        raise HTTPException(status_code=400, detail=f"booking not found with this session id, Error: {str(e)}")
+    if not booking:
+        raise HTTPException(status_code=400, detail="booking not found with this session id")
+    booking.listing_selected_date = listing_selected_date
+    booking.listing_selected_time = listing_selected_time
     if confirmation == "confirmed":
-        logger.warning(f"Property Schudule is confirmed by listing agent.")
-        property.status = "confirmed"
-        listing_agent_body = f"Your showing at {property.address} (MLS # {property.mls_number}) is confirmed on {listing_selected_date} at {listing_selected_time}. I'll send you a reminder the day before to ensure you're prepared."
-        buyer_agent_body = f"Your showing at {property.address} (MLS # {property.mls_number}) is confirmed by {listing_user.full_name} on {listing_selected_date} at {listing_selected_time}. I'll send you a reminder the day before to ensure you're prepared."
+        logger.warning(f"booking Schudule is confirmed by listing agent.")
+        booking.status = "confirmed"
+        listing_agent_body = f"Your showing at {booking.address} (MLS # {booking.mls_number}) is confirmed on {listing_selected_date} at {listing_selected_time}. I'll send you a reminder the day before to ensure you're prepared."
+        buyer_agent_body = f"Your showing at {booking.address} (MLS # {booking.mls_number}) is confirmed by {listing_user.full_name} on {listing_selected_date} at {listing_selected_time}. I'll send you a reminder the day before to ensure you're prepared."
     elif confirmation == "cancelled":
-        logger.warning(f"Property Schudule is cancelled by listing agent.")
-        property.status = "cancelled"
+        logger.warning(f"booking Schudule is cancelled by listing agent.")
+        booking.status = "cancelled"
         listing_agent_body = f"Thank you for letting us know. We will inform the buyer that the showing has been cancelled."
         buyer_agent_body = f"Unfortunately, the listing agent has cancelled the showing. We apologize for any inconvenience caused."
     elif confirmation == "reschedule":
-        logger.warning(f"Property Schudule is rescheduled by listing agent. because of listing_selected_date: {listing_selected_date}, listing_selected_time: {listing_selected_time} and buyer_selected_date: {property.buyer_selected_date}, buyer_selected_time: {property.buyer_selected_time}")
-        property.status = "rescheduled"
+        logger.warning(f"booking Schudule is rescheduled by listing agent. because of listing_selected_date: {listing_selected_date}, listing_selected_time: {listing_selected_time} and buyer_selected_date: {booking.buyer_selected_date}, buyer_selected_time: {booking.buyer_selected_time}")
+        booking.status = "rescheduled"
         listing_agent_body = f"Thank you for letting us know. I will inform the buyer agent that you have rescheduled the showing on {listing_selected_date} at {listing_selected_time}."
-        buyer_agent_body = f"The listing agent for the property at {property.address} (MLS # {property.mls_number}) has rescheduled the showing on {listing_selected_date} at {listing_selected_time}. Please confirm if this new time works for you."
+        buyer_agent_body = f"The listing agent for the booking at {booking.address} (MLS # {booking.mls_number}) has rescheduled the showing on {listing_selected_date} at {listing_selected_time}. Please confirm if this new time works for you."
     else:
         raise HTTPException(status_code=400, detail="Invalid confirmation status")
 
-    logger.warning(f"Property Schudule is {confirmation} by listing agent. listing_agent_body: {listing_agent_body}, buyer_agent_body: {buyer_agent_body}")
+    logger.warning(f"booking Schudule is {confirmation} by listing agent. listing_agent_body: {listing_agent_body}, buyer_agent_body: {buyer_agent_body}")
     try:
-        logger.info(f"Sending message to listing agent from: {ai_agnet_number}, body: {listing_agent_body}, to: {property.buyer_agent_phone_number}")
-        payload  = create_payload_for_whatsapp_message(from_number=property.buyer_agent_phone_number, to_number=ai_agnet_number, body=buyer_agent_body)
+        logger.info(f"Sending message to listing agent from: {ai_agnet_number}, body: {listing_agent_body}, to: {booking.buyer_agent_phone_number}")
+        payload  = create_payload_for_whatsapp_message(from_number=booking.buyer_agent_phone_number, to_number=ai_agnet_number, body=buyer_agent_body)
         headers = {"Content-Type": "application/json"}
         response = requests.post(n8n_webhook_url, headers=headers, data=json.dumps(payload))
         logger.info(f"Response for whatsapp webhook: {response.text}")

app/services/agent.py

@@ -0,0 +1,8 @@
+
+
+def verify_agent_by_agent_id_and_broker_name(agent_id, broker_name):
+    if agent_id == "agent_id_test" and broker_name == "broker_name_test":
+        return True
+    elif agent_id == "king_agent" and broker_name == "king_broker":
+        return True
+    return False

app/services/properties.py

@@ -0,0 +1,51 @@
+from utils.log_utils import setup_logger
+
+logger = setup_logger("properties_service")
+
+def get_property_by_address_or_mls_number(mls_number, address):
+    if mls_number == "123456":
+        response = {
+            "address": "123 Main St, San Francisco, CA 94105",
+            "mls_number": mls_number,
+            "price": "$1,000,000",
+            "bedrooms": "3",
+            "bathrooms": "2",
+            "sqft": "1,500",
+            "lot_size": "0.25",
+            "year_built": "2000",
+            "description": "This is a beautiful 3 bedroom, 2 bathroom home with 1,500 sqft of living space on a 0.25 acre lot. The home was built in 2000 and is listed for $1,000,000.",
+            "agent_name": "Alice",
+            "agent_phone": "+917347256305"
+        }
+    elif mls_number == "654321":
+        response = {
+            "address": "456 Elm St, San Francisco, CA 94105",
+            "mls_number": mls_number,
+            "price": "$1,500,000",
+            "bedrooms": "4",
+            "bathrooms": "3",
+            "sqft": "2,000",
+            "lot_size": "0.5",
+            "year_built": "2010",
+            "description": "This is a beautiful 4 bedroom, 3 bathroom home with 2,000 sqft of living space on a 0.5 acre lot. The home was built in 2010 and is listed for $1,500,000.",
+            "agent_name": "Alice2",
+            "agent_phone": "+917347256302"
+        }
+    elif address == "321 Oak St, San Francisco, CA 94105":
+        response = {
+            "address": address,
+            "mls_number": "789012",
+            "price": "$2,000,000",
+            "bedrooms": "5",
+            "bathrooms": "4",
+            "sqft": "2,500",
+            "lot_size": "0.75",
+            "year_built": "2020",
+            "description": "This is a beautiful 5 bedroom, 4 bathroom home with 2,500 sqft of living space on a 0.75 acre lot. The home was built in 2020 and is listed for $2,000,000.",
+            "agent_name": "Alice3",
+            "agent_phone": "+917347256303"
+        }
+    else:
+        logger.warning(f"Property not found for address: {address}, mls_number: {mls_number}")
+        response = {}
+    return response