Upload 18 files

app/api/router.py

@@ -0,0 +1,240 @@
+from app.db import models
+import os, json, random, requests
+from sqlalchemy.orm import Session
+from fastapi.responses import JSONResponse
+from app.db.database import SessionLocal, engine
+from app.db import crud
+from app.services.realtor_service import RealtorService
+from app.utils.log_utils import setup_logger
+from fastapi import Request, Depends, APIRouter, HTTPException
+from twilio.twiml.messaging_response import MessagingResponse
+from app.services.properties_service import get_property_by_address_or_mls_number
+from app.services.agent_service import verify_agent_by_agent_id_and_broker_name
+from fastapi.responses import Response
+from pydantic import BaseModel, Field
+from twilio.rest import Client
+from app.db.schemas import BuyerRealtorConfirmation, BuyerRealtorSignUP, CreatebookingRequest, GetBooking, ListingRealtorConfirmation, ListingRealtorSignUP, MessageRequestSignUP
+
+from dotenv import load_dotenv
+load_dotenv()
+
+logger = setup_logger("router")
+
+ACCOUNT_SID = os.getenv("ACCOUNT_SID")
+AUTH_TOKEN = os.getenv("AUTH_TOKEN")
+ai_agnet_number = os.getenv("AI_AGENT_NUMBER")
+n8n_webhook_url = os.getenv("N8N_WEBHOOK_URL")
+
+client = Client(ACCOUNT_SID, AUTH_TOKEN)
+
+router = APIRouter()
+models.Base.metadata.create_all(bind=engine)
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield 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)
+
+@router.post('/realtor/signup')
+async def realtor_sign_up(request: MessageRequestSignUP, db: Session = Depends(get_db)):
+    logger.warning(f"singup request: {request}")
+    user = crud.create_user(db, full_name=request.full_name, phone_number=request.phone_number, type=request.type, agent_id=request.agent_id, broker_name=request.broker_name)
+    if not user:
+        raise HTTPException(status_code=400, detail="User creation failed")
+    return JSONResponse(content="user is signed up sucessfully.")
+
+
+@router.post('/realtor/create_booking')
+async def create_booking(request: CreatebookingRequest, db: Session = Depends(get_db)):
+    logger.warning(f"Create booking request: {request}")
+    try:
+        booking = crud.create_booking(db, buyer_agent_phone_number=request.buyer_agent_phone_number,
+                                            address=request.address, mls_number=request.mls_number, buyer_selected_date=request.buyer_selected_date,
+                                            buyer_selected_time=request.buyer_selected_time, listing_agent_phone_number=request.listing_agent_phone_number,
+                                            listing_agent_session_id=request.listing_agent_session_id, status=request.status)
+    except Exception as e:
+        db.rollback()
+        logger.error(f"Error in creating booking: {e}")
+        raise HTTPException(status_code=400, detail="booking creation failed")
+
+    return JSONResponse(content=booking)
+
+
+
+@router.post('/realtor/book_showings')
+async def buyer_book_showings(request: ListingRealtorSignUP, db: Session = Depends(get_db)):
+    logger.warning(f"Listing realtor singup request: {request}")
+    realtor_service = RealtorService()
+    response = realtor_service.book_showings(db, request.booking_address, request.mls_number, request.date, request.time, request.buyer_agent_phone_number)
+    logger.warning(f"Listing realtor sign up response: {response}")
+    return JSONResponse(content=response)
+
+@router.post('/realtor/get_booking')
+async def get_booking(request: GetBooking, db: Session = Depends(get_db)):
+    realtor_service = RealtorService()
+    response = realtor_service.get_booking(db,  booking_id=request.booking_id, mls_number=request.mls_number, phone_number=request.phone_number)
+    logger.warning(f"Get booking response: {response}")
+    return JSONResponse(content=response)
+
+@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}")
+    type = "buyer"
+    realtor_service = RealtorService()
+    response = realtor_service.buyer_realtor_sign_up(db, request.full_name, request.agent_id, request.broker_name, request.phone_number, type)
+    logger.warning(f"Buyer realtor sign up response: {response}")
+    return JSONResponse(content=response)
+
+@router.post('/buyer_realtor/confirmation')
+async def buyer_realtor_confirmation(request: BuyerRealtorConfirmation, db: Session = Depends(get_db)):
+    logger.warning(f"Buyer realtor confirmation request: {request}")
+    realtor_service = RealtorService()
+    response = realtor_service.buyer_realtor_confirmation(db, request.phone_number, request.booking_id, request.mls_number, request.date, request.time, request.confirmation)
+    logger.warning(f"Buyer realtor confirmation response: {response}")
+    return JSONResponse(content=response)
+
+@router.post('/listing_realtor/confirmation')
+async def listing_realtor_confirmation(request: ListingRealtorConfirmation, db: Session = Depends(get_db)):
+    logger.warning(f"Listing realtor confirmation request: {request}")
+    realtor_service = RealtorService()
+    response = realtor_service.listing_realtor_confirmation(db, request.session_id, request.date, request.time, request.confirmation)
+    logger.warning(f"Listing realtor confirmation response: {response}")
+    return JSONResponse(content=response)
+
+
+
+# @router.post("/webhook/sms")
+# async def receive_sms(request: Request):
+#     form_data = await request.form()
+#     logger.warning(f"Received SMS: {form_data}")
+#     sender = form_data.get("From")[9:]
+#     message_body = form_data.get("Body")
+
+#     logger.warning(f"Received SMS from {sender}: {message_body}")
+#     # # Reply to the sender
+#     # response = MessagingResponse()
+#     # response.message(f"Hello! You sent: {message_body}")
+
+#     # return str(response)
+
+
+@router.get('/helth_check')
+async def helth_check():
+    logger.warning(f"singup request: Comes")
+    return JSONResponse(content="Success")
+
+@router.get('/')
+async def test():
+    logger.warning(f"test request: Comes")
+    return JSONResponse(content="Go to /docs")
+
+
+@router.post('/chatbot')
+async def whatsapp_webhook(request: Request, db: Session = Depends(get_db)):
+    form_data = await request.form()
+    num_media = int(form_data.get('NumMedia', 0))
+    phone_number = form_data.get("From")[9:]
+    profile_name = form_data.get("ProfileName")
+    user_query = form_data.get("Body")
+    logger.warning(f"num_media: {num_media}, phone_number: {phone_number}, ProfileName: {profile_name}, user_query: {user_query}")
+
+    user = crud.get_user_by_phone_number(db, phone_number=phone_number)
+    if not user:
+        payload = {
+            "input_value": user_query,
+            "session_id": phone_number
+        }
+        logger.info(f"Payload: {payload}")
+        headers = {
+            'Content-Type': 'application/json'
+        }
+        url = "https://workflows.kickcall.ai/api/v1/run/067c7617-4758-4f07-8f4e-457b4d10dbb6?stream=false&user_id=1"
+
+        try:
+            response = requests.post(url, headers=headers, data=json.dumps(payload))
+            logger.info(f"[Langflow][run] Response status code received: {response.status_code}")
+
+            if response.status_code == 200:
+                response_json = response.json()
+                logger.info(f"[Langflow][run] Response: {response_json}")
+                output_text = response_json["outputs"][0]["outputs"][0]["results"]["message"]["data"]["text"]
+
+                bot_resp = MessagingResponse()
+                msg = bot_resp.message()
+                msg.body(output_text)
+
+                return Response(content=str(bot_resp), media_type="application/xml")
+            else:
+                logger.info(f"Error: Received status code {response.status_code}")
+                bot_resp = MessagingResponse()
+                msg = bot_resp.message()
+                msg.body("I'm sorry, I couldn't process your request at the moment. Please try again later.")
+                return Response(content=str(bot_resp), media_type="application/xml")
+
+        except Exception as e:
+            logger.info(f"Error in processing user query: {e}")
+            bot_resp = MessagingResponse()
+            msg = bot_resp.message()
+            msg.body("I'm sorry, an unexpected error occurred. Please try again later.")
+            return Response(content=str(bot_resp), media_type="application/xml")
+
+    if user.type == "buyer":
+        payload = {
+            "input_value": user_query,
+            "session_id": phone_number
+        }
+        logger.info(f"Payload: {payload}")
+        headers = {
+            'Content-Type': 'application/json'
+        }
+        url = "https://workflows.kickcall.ai/api/v1/run/c94b14f5-d7a7-4fc8-89d8-eb672716c778?stream=false&user_id=1"
+
+        try:
+            response = requests.post(url, headers=headers, data=json.dumps(payload))
+            logger.info(f"[Langflow][run] Response status code received: {response.status_code}")
+
+            if response.status_code == 200:
+                response_json = response.json()
+                logger.info(f"[Langflow][run] Response: {response_json}")
+                output_text = response_json["outputs"][0]["outputs"][0]["results"]["message"]["data"]["text"]
+
+                bot_resp = MessagingResponse()
+                msg = bot_resp.message()
+                msg.body(output_text)
+
+                return Response(content=str(bot_resp), media_type="application/xml")
+            else:
+                logger.info(f"Error: Received status code {response.status_code}")
+                bot_resp = MessagingResponse()
+                msg = bot_resp.message()
+                msg.body("I'm sorry, I couldn't process your request at the moment. Please try again later.")
+                return Response(content=str(bot_resp), media_type="application/xml")
+
+        except Exception as e:
+            logger.info(f"Error in processing user query: {e}")
+            bot_resp = MessagingResponse()
+            msg = bot_resp.message()
+            msg.body("I'm sorry, an unexpected error occurred. Please try again later.")
+            return Response(content=str(bot_resp), media_type="application/xml")
+
+    elif user.type == "listing":
+        logger.info(f"Message received by listing realto's ")
+        active_session_id = user.active_session_id
+
+    else:
+        logger.error(f"Message received by  type : {user.type}")
+

app/db/crud.py

@@ -0,0 +1,77 @@
+import uuid
+from app.db import models
+from sqlalchemy.orm import Session
+from app.utils.log_utils import setup_logger
+
+logger = setup_logger("crud")
+
+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):
+    return db.query(models.User).filter(models.User.phone_number == phone_number).first()
+
+def create_user(db: Session, full_name: str, phone_number: str, type: str, agent_id=None, broker_name=None, active_session_id=None):
+    try:
+        new_user = models.User(full_name=full_name,
+                                phone_number=phone_number,
+                                type=type,
+                                agent_id=agent_id,
+                                broker_name=broker_name,
+                                active_session_id=active_session_id)
+        db.add(new_user)
+        db.commit()
+        db.refresh(new_user)
+        return new_user
+    except Exception as e:
+        db.rollback()
+        logger.error(f"Error creating user: {e}")
+        return None
+
+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 get_booking_by_id(db: Session, booking_id: int):
+    return db.query(models.booking).filter(models.booking.id == booking_id).first()
+
+def get_booking_by_id_and_buyer_agent_phone_number(db: Session, booking_id: int, buyer_agent_phone_number: str):
+    return db.query(models.booking).filter(models.booking.id == booking_id,
+                                           models.booking.buyer_agent_phone_number == buyer_agent_phone_number).first()
+
+def get_booking_by_mls_number_and_buyer_agent_phone_number(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 create_booking(db: Session,
+                    buyer_agent_phone_number: str,
+                    address: str, mls_number: str,
+                    buyer_selected_date: str,
+                    buyer_selected_time: str,
+                    listing_selected_date: str = None,
+                    listing_selected_time: str = None,
+                    listing_agent_phone_number: str = None,
+                    listing_agent_session_id: str = None,
+                    status: str = None):
+    try:
+        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,
+                                    buyer_selected_time=buyer_selected_time,
+                                    listing_selected_date=listing_selected_date,
+                                    listing_selected_time=listing_selected_time,
+                                    listing_agent_phone_number=listing_agent_phone_number,
+                                    listing_agent_session_id=listing_agent_session_id,
+                                    status=status)
+        db.add(new_booking)
+        db.commit()
+        db.refresh(new_booking)
+        return new_booking
+    except Exception as e:
+        db.rollback()
+        print(f"Error creating booking: {e}")
+        return None

app/db/database.py

@@ -0,0 +1,17 @@
+import os
+from dotenv import load_dotenv
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.declarative import declarative_base
+
+load_dotenv()
+
+SQLALCHEMY_DATABASE_URL = os.getenv("POSTGRES_DATABASE_URL")
+
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL,
+    pool_pre_ping=True
+)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()

app/db/models.py

@@ -0,0 +1,37 @@
+from sqlalchemy import Column, Integer, JSON,ForeignKey, String, DateTime, func, ARRAY
+from sqlalchemy.orm import relationship
+from .database import Base
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    phone_number = Column(String, unique=True, index=True)
+    full_name = Column(String, default="Unknown")
+    agent_id = Column(String, default="")
+    type = Column(String, default="buyer")
+    broker_name = Column(String, default="")
+    active_session_id = Column(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())
+
+    bookings = relationship("booking", back_populates="buyer_agent")
+
+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)
+    address = Column(String, default="")
+    mls_number = Column(String, default="")
+    buyer_selected_date = Column(String, default="")
+    buyer_selected_time = Column(String, default="")
+    listing_selected_date = Column(String, default="")
+    listing_selected_time = Column(String, default="")
+    listing_agent_phone_number = Column(String, default="")
+    listing_agent_session_id = Column(String, default="")
+    status = Column(String, default="pending")
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    buyer_agent = relationship("User", back_populates="bookings")

app/db/schemas.py

@@ -0,0 +1,52 @@
+from pydantic import BaseModel, Field
+
+class MessageRequestSignUP(BaseModel):
+    phone_number: str = Field(default="+917389058485")
+    agent_id: str = Field(default="")
+    full_name: str = Field(default="agent_full_name")
+    broker_name: str = Field(default="")
+    type: str = Field(default="buyer")
+    listing_realtor_msg: str = Field(default="")
+
+
+class CreatebookingRequest(BaseModel):
+    buyer_agent_phone_number: str = Field(default="+917389058485")
+    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")
+    listing_agent_phone_number: str = Field(default="")
+    listing_agent_session_id: str = Field(default="")
+    status: str = Field(default="pending")
+
+class BuyerRealtorSignUP(BaseModel):
+    full_name: str = Field(default="")
+    agent_id: str = Field(default="")
+    broker_name: str = Field(default="")
+    phone_number: str = Field(default="")
+
+class ListingRealtorSignUP(BaseModel):
+    booking_address: str = Field(default="")
+    mls_number: str = Field(default="")
+    date: str = Field(default="")
+    time: str = Field(default="")
+    buyer_agent_phone_number: str = Field(default="")
+
+class BuyerRealtorConfirmation(BaseModel):
+    phone_number: str = Field(default="")
+    mls_number: str = Field(default="")
+    booking_id: str = Field(default="")
+    date: str = Field(default="")
+    time: str = Field(default="")
+    confirmation: str = Field(default="")
+
+class ListingRealtorConfirmation(BaseModel):
+    confirmation: str = Field(default="")
+    date: str = Field(default="")
+    time: str = Field(default="")
+    session_id: str = Field(default="")
+
+class GetBooking(BaseModel):
+    phone_number: str = Field(default="")
+    booking_id: str = Field(default="")
+    mls_number: str = Field(default="")

app/services/agent_service.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_service.py

@@ -0,0 +1,51 @@
+from app.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 in ["123", "456", "789", "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": "Bob",
+            "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": "Bob1",
+            "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": "Bob2",
+            "agent_phone": "+917347256303"
+        }
+    else:
+        logger.error(f"Property not found for address: {address}, mls_number: {mls_number}")
+        response = None
+    return response

app/services/realtor_service.py

@@ -0,0 +1,264 @@
+from app.db import crud
+from app.services.agent_service import verify_agent_by_agent_id_and_broker_name
+from app.services.properties_service import get_property_by_address_or_mls_number
+from app.utils.log_utils import setup_logger
+import requests, os, json, uuid
+from dotenv import load_dotenv
+load_dotenv()
+
+ACCOUNT_SID = os.getenv("ACCOUNT_SID")
+AUTH_TOKEN = os.getenv("AUTH_TOKEN")
+ai_agnet_number = os.getenv("AI_AGENT_NUMBER")
+n8n_webhook_url = os.getenv("N8N_WEBHOOK_URL")
+
+logger = setup_logger("realtor_service")
+
+def create_payload_for_whatsapp_message(from_number, to_number, body):
+    payload = [
+        {
+            "SmsMessageSid": "SM0b07afa5f1ede39427957b4dc127cab3",
+            "NumMedia": "0",
+            "ProfileName": "",
+            "MessageType": "text",
+            "SmsSid": "SM0b07afa5f1ede39427957b4dc127cab3",
+            "WaId": from_number,
+            "SmsStatus": "received",
+            "Body": f"paparaphrase this: {body}",
+            "To": f"whatsapp:{to_number}",
+            "NumSegments": "1",
+            "ReferralNumMedia": "0",
+            "MessageSid": "SM0b07afa5f1ede39427957b4dc127cab3",
+            "AccountSid": "",
+            "From": f"whatsapp:{from_number}",
+            "ApiVersion": "2010-04-01"
+        }
+    ]
+
+    try:
+
+        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}")
+    except Exception as e:
+        logger.error(f"Error in sending message to agent: {e}")
+        return f"Error in sending message to agent: {str(e)}"
+    return "Message sent successfully"
+
+
+class RealtorService:
+    def __init__(self):
+        pass
+
+    def book_showings(self, db, booking_address, mls_number, date, time, buyer_agent_phone_number):
+        buyer_selected_date = date
+        buyer_selected_time = time
+        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 is None:
+            return "Invalid mls_number or address"
+        listing_agent_full_name = response["agent_name"]
+        listing_agent_phone_number = response["agent_phone"]
+        type = "listing"
+        booking_address = response["address"]
+        try:
+            buyer_user = crud.get_user_by_phone_number(db, phone_number=buyer_agent_phone_number)
+            if not buyer_user:
+                return "Buyer agent not found"
+
+            new_session_id = uuid.uuid4()
+            listing_user = crud.get_user_by_phone_number(db, phone_number=listing_agent_phone_number)
+            if listing_user:
+                if listing_user.active_session_id:
+                    listing_user.queued_session_ids = listing_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: {buyer_agent_phone_number}")
+                    db.commit()
+                    db.refresh(listing_user)
+                    booking = crud.get_booking_by_mls_number_and_buyer_agent_phone_number(db, mls_number=mls_number, buyer_agent_phone_number=buyer_agent_phone_number)
+                    if booking:
+                        booking.buyer_selected_date = buyer_selected_date
+                        booking.buyer_selected_time = buyer_selected_time
+                        db.commit()
+                        db.refresh(booking)
+                        return f"A booking already exists with this MLS number. The rescheduling request has been successfully processed. Your booking ID is {booking.id} for future reference."
+                    else:
+                        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=new_session_id)
+                else:
+                    logger.info(f"The user already exists but no active session found : {buyer_agent_phone_number}")
+                    listing_user.active_session_id = new_session_id
+                    db.commit()
+                    db.refresh(listing_user)
+                    booking = crud.get_booking_by_mls_number_and_buyer_agent_phone_number(db, mls_number=mls_number, buyer_agent_phone_number=buyer_agent_phone_number)
+                    if booking:
+                        booking.buyer_selected_date = buyer_selected_date
+                        booking.buyer_selected_time = buyer_selected_time
+                        db.commit()
+                        db.refresh(booking)
+                        return f"Rescheduling request has been successfully processed. Your booking ID is {booking.id}."
+                    else:
+                        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)
+            else:
+                listing_user = crud.create_user(db, full_name=listing_agent_full_name, phone_number=listing_agent_phone_number, type=type, active_session_id=new_session_id)
+                if not listing_user:
+                    logger.info(f"Error in creating listing agent.")
+                    return "Error in creating listing agent."
+                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=new_session_id)
+
+        except Exception as e:
+            db.rollback()
+            logger.error(f"Error in creating booking: {e}")
+            return "booking creation failed"
+
+        if int(buyer_selected_time[:2])>12:
+            buyer_selected_time = f"{int(buyer_selected_time[:2])-12}{buyer_selected_time[2:]} PM"
+        else:
+            buyer_selected_time = f"{buyer_selected_time} AM"
+
+        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}. The booking ID for this request is #{booking.id} for future reference. Can you make that work?."
+        logger.info(f"Sending message to listing agent from: {ai_agnet_number}, body: {listing_agent_body}, to: {listing_agent_phone_number}")
+        response = create_payload_for_whatsapp_message(from_number=listing_agent_phone_number, to_number=ai_agnet_number, body=listing_agent_body)
+        if response == "Message sent successfully":
+            return f"Do not say like its booked successfully say like: Your showing has been pending with the listing agent {listing_user.full_name}. I will notify you once the listing agent confirms the showing appointment. Your booking ID is #{booking.id} for future reference."
+        return "Error in sending message to listing agent"
+
+
+    def listing_realtor_confirmation(self, db, session_id, listing_selected_date, listing_selected_time, confirmation):
+        logger.warning(f"Listing realtore - listing_selected_date: {listing_selected_date}, listing_selected_time: {listing_selected_time}, session_id: {session_id}, confirmation: {confirmation}.")
+        try:
+            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)
+            is_listing_user_session_queued = False
+        except Exception as e:
+            logger.error(f"Error in creating user: {e}")
+            return f"booking not found with this session id, Error: {str(e)}"
+        if not booking:
+            return "booking not found with this session id"
+        booking.listing_selected_date = listing_selected_date
+        booking.listing_selected_time = listing_selected_time
+
+        if listing_selected_date == booking.buyer_selected_date and listing_selected_time == booking.buyer_selected_time:
+            logger.info(f"listing_selected_date and listing_selected_time are same as buyer_selected_date and buyer_selected_time")
+            confirmation = "confirmed"
+        if int(listing_selected_time[:2])>12:
+            listing_selected_time = f"{int(listing_selected_time[:2])-12}{listing_selected_time[2:]} PM"
+        else:
+            listing_selected_time = f"{listing_selected_time} AM"
+        if confirmation == "confirmed":
+            logger.warning(f"booking Schudule is confirmed by listing agent.")
+            booking.status = "confirmed"
+            if listing_user.queued_session_ids:
+                logger.info(f"listing user has queued sessions Found.")
+                listing_user.active_session_id = listing_user.queued_session_ids.pop(0)
+                is_listing_user_session_queued = True
+            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"booking Schudule is cancelled by listing agent.")
+            if listing_user.queued_session_ids:
+                logger.info(f"listing user has queued sessions Found.")
+                listing_user.active_session_id = listing_user.queued_session_ids.pop(0)
+                is_listing_user_session_queued = True
+            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 == "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"paparaphrase this: Your reschedule request for the showing has been submitted and is waiting for confirmation from the buyer agent. I’ll update you once they confirm the showing appointment. Your booking ID is #{booking.id} for reference."
+            buyer_agent_body = f"The listing agent for the booking at {booking.address} (MLS # {booking.mls_number}) wants to rescheduled the showing on {listing_selected_date} at {listing_selected_time} . Your booking ID is #{booking.id} for future reference, Please confirm if this new time works for you."
+        else:
+            logger.warning(f"Invalid confirmation status")
+            return "Invalid confirmation status"
+
+        logger.info(f"Sending message to listing agent from: {ai_agnet_number}, body: {buyer_agent_body}, to: {booking.buyer_agent_phone_number}")
+        response = create_payload_for_whatsapp_message(from_number=booking.buyer_agent_phone_number, to_number=ai_agnet_number, body=buyer_agent_body)
+        if response != "Message sent successfully":
+            logger.error(f"Error in sending message to listing agent")
+            return "Error in sending message to buyer agent"
+        db.commit()
+        return listing_agent_body
+
+    def buyer_realtor_confirmation(self, db, buyer_agent_phone_number, booking_id, mls_number, buyer_selected_date, buyer_selected_time, confirmation):
+        logger.warning(f"Buyer realtore - booking_id: {booking_id}, mls_number: {mls_number}, buyer_selected_date: {buyer_selected_date}, buyer_selected_time: {buyer_selected_time}, confirmation: {confirmation}.")
+        try:
+            if booking_id:
+                booking = crud.get_booking_by_id_and_buyer_agent_phone_number(db, booking_id=booking_id, buyer_agent_phone_number=buyer_agent_phone_number)
+            elif mls_number:
+                booking = crud.get_booking_by_mls_number_and_buyer_agent_phone_number(db, mls_number=mls_number, buyer_agent_phone_number=buyer_agent_phone_number)
+            else:
+                return "Invalid booking id or mls number"
+        except Exception as e:
+            logger.error(f"Error in creating user: {e}")
+            return f"booking not found with this booking id, Error: {str(e)}"
+        if not booking:
+            return "booking not found with this booking id"
+        booking.buyer_selected_date = buyer_selected_date
+        booking.buyer_selected_time = buyer_selected_time
+        if buyer_selected_date == booking.listing_selected_date and buyer_selected_time == booking.listing_selected_time:
+            logger.info(f"buyer_selected_date and buyer_selected_time are same as listing_selected_date and listing_selected_time")
+            confirmation = "confirmed"
+        if int(buyer_selected_time[:2])>12:
+            buyer_selected_time = f"{int(buyer_selected_time[:2])-12}{buyer_selected_time[2:]} PM"
+        else:
+            buyer_selected_time = f"{buyer_selected_time} AM"
+        if confirmation == "confirmed":
+            logger.warning(f"booking Schudule is confirmed by buyer agent.")
+            booking.status = "confirmed"
+            buyer_agent_body = f"Your showing at {booking.address} (MLS # {booking.mls_number}) is confirmed on {buyer_selected_date} at {buyer_selected_time}. Your booking ID is {booking.id} for future reference. I'll send you a reminder the day before to ensure you're prepared."
+            listing_agent_body = f"Your showing at {booking.address} (MLS # {booking.mls_number}) is confirmed on {buyer_selected_date} at {buyer_selected_time} . Your booking ID is {booking.id} for future reference. I'll send you a reminder the day before to ensure you're prepared."
+        elif confirmation == "cancelled":
+            logger.warning(f"booking Schudule is cancelled by buyer agent.")
+            booking.status = "cancelled"
+            buyer_agent_body = f"Thank you for letting us know. We will inform the listing Agent that the showing has been cancelled."
+            listing_agent_body = f"Unfortunately, the Buyer agent has cancelled the showing. We apologize for any inconvenience caused."
+        elif confirmation == "rescheduled":
+            logger.warning(f"booking Schudule is rescheduled by Buyer agent. because of listing_selected_date: {buyer_selected_date}, listing_selected_time: {buyer_selected_time} and buyer_selected_date: {booking.buyer_selected_date}, buyer_selected_time: {booking.buyer_selected_time}")
+            booking.status = "rescheduled"
+            buyer_agent_body = f"paparaphrase this: Your reschedule request for the showing has been submitted and is waiting for confirmation from the buyer agent. I’ll update you once they confirm the showing appointment. Your booking ID is #{booking.id} for reference."
+            listing_agent_body = f"The Buyer agent for the booking at {booking.address} (MLS # {booking.mls_number}) wants to rescheduled the showing on {buyer_selected_date} at {buyer_selected_time}. Your booking ID is #{booking.id} for future reference. Please confirm if this new time works for you."
+        else:
+            logger.warning(f"Invalid confirmation status")
+            return "Invalid confirmation status"
+
+        logger.info(f"Sending message to listing agent from: {ai_agnet_number}, body: {listing_agent_body}, to: {booking.listing_agent_phone_number}")
+        response = create_payload_for_whatsapp_message(from_number=booking.listing_agent_phone_number, to_number=ai_agnet_number, body=listing_agent_body)
+        if response != "Message sent successfully":
+            logger.error(f"Error in sending message to listing agent")
+            return "Error in sending message to Listing agent"
+        db.commit()
+        return buyer_agent_body
+
+
+    def buyer_realtor_sign_up(self, db, full_name, agent_id, broker_name, phone_number, type):
+        logger.warning(f"Buyer realtor singup request: {full_name}, {agent_id}, {broker_name}, {phone_number}, {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):
+            logger.warning(f"Invalid agent_id or broker_name")
+            return "Wrong 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)
+        if not user:
+            "User creation failed"
+        return "user is signed up sucessfully. Now you can book the showing with the listing agent. would you like to book a showing now?"
+
+
+    def get_booking(self, db, booking_id, mls_number, phone_number):
+        logger.warning(f"Get booking request: {booking_id}, {mls_number}, {phone_number}")
+        if booking_id:
+            booking = crud.get_booking_by_id_and_buyer_agent_phone_number(db, booking_id=booking_id, buyer_agent_phone_number=phone_number)
+        elif mls_number:
+            booking = crud.get_booking_by_mls_number_and_buyer_agent_phone_number(db, mls_number=mls_number, buyer_agent_phone_number=phone_number)
+        else:
+            return "Invalid booking_id or mls_number or phone_number"
+        if not booking:
+            return "booking not found"
+        logger.info(f"booking details: {str(vars(booking))}")
+        return str(vars(booking))

app/utils/log_utils.py

@@ -0,0 +1,26 @@
+import logging
+import colorlog
+
+def setup_logger(logger_name: str, debug_color="white", info_color="green", propagate=False):
+    color_handler = colorlog.StreamHandler()
+    log_colors = {
+        "DEBUG": debug_color,
+        "INFO": info_color,
+        "WARNING": "yellow",
+        "ERROR": "red",
+        "CRITICAL": "bold_red",
+    }
+    color_handler.setFormatter(
+        colorlog.ColoredFormatter(
+            "%(log_color)s%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+            log_colors=log_colors
+        )
+    )
+    logger = logging.getLogger(logger_name)
+    if logger.hasHandlers():
+        logger.handlers.clear()
+    logger.setLevel(logging.DEBUG)
+    logger.addHandler(color_handler)
+    logger.propagate = propagate
+    return logger