Enhance WhatsApp message handling: Add message timestamp extraction and message-age condition

Author: OdyAsh

src/ansari/app/main_whatsapp.py

@@ -102,6 +102,7 @@ async def main_webhook(request: Request, background_tasks: BackgroundTasks) -> R
             incoming_msg_type,
             incoming_msg_body,
             message_id,
+            message_unix_time,
         ) = await presenter.extract_relevant_whatsapp_message_details(data)
     except Exception as e:
         logger.error(f"Error extracting message details: {e}")
@@ -117,22 +118,24 @@ async def main_webhook(request: Request, background_tasks: BackgroundTasks) -> R
     # Terminate if whatsapp is not enabled (i.e., via .env configurations, etc)
     if not whatsapp_enabled:
         # Create a temporary user-specific presenter just to send the message
-        temp_presenter = WhatsAppPresenter.create_user_specific_presenter(presenter, from_whatsapp_number, None, None, None)
+        temp_presenter = WhatsAppPresenter.create_user_specific_presenter(
+            presenter, from_whatsapp_number, None, None, None, None
+        )
         background_tasks.add_task(
             temp_presenter.send_whatsapp_message,
             "Ansari for WhatsApp is down for maintenance, please try again later or visit our website at https://ansari.chat.",
         )
         return Response(status_code=200)
 
-    # Workaround while locally developing:
-    #   don't process other dev's whatsapp recepient phone nums coming from staging env.
-    #   (as both stage Meta app / local-.env-file have same testing number)
-    dev_num_sub_str = "YOUR_DEV_PHONE_NUM"
-    if get_settings().DEV_MODE and dev_num_sub_str not in from_whatsapp_number:
-        logger.debug(
-            f"Incoming message from {from_whatsapp_number} (doesn't have this sub-str: {dev_num_sub_str}). \
-            Therefore, will not process it as it's not cur. dev."
-        )
+    # Temporarycorner case while locally developing:
+    #   Since the staging server is always running,
+    #   and since we currently have the same testing number for both staging and local testing,
+    #   therefore we need an indicator that a message is meant for a dev who's testing locally now
+    #   and not for the staging server.
+    #   This is done by prefixing the message with "!d " (e.g., "!d what is ansari?")
+    # NOTE: Obviously, this temp. solution will be removed when we get a dedicated testing number for staging testing.
+    if get_settings().DEPLOYMENT_TYPE == "staging" and incoming_msg_body.get("body", "").startswith("!d "):
+        logger.debug("Incoming message is meant for a dev who's testing locally now, so will not process it in staging...")
         return Response(status_code=200)
 
     # Create a user-specific presenter for this message
@@ -142,6 +145,7 @@ async def main_webhook(request: Request, background_tasks: BackgroundTasks) -> R
         incoming_msg_type,
         incoming_msg_body,
         message_id,
+        message_unix_time,
     )
 
     # Start the typing indicator loop that will continue until message is processed
@@ -159,6 +163,22 @@ async def main_webhook(request: Request, background_tasks: BackgroundTasks) -> R
         )
         return Response(status_code=200)
 
+    # Check if there are more than 24 hours have passed from the user's message to the current time
+    # If so, send a message to the user and return
+    if user_presenter.is_message_too_old():
+        response_msg = "Sorry, your message "
+        user_msg_start = " ".join(incoming_msg_body.get("body", "").split(" ")[:5])
+        if user_msg_start:
+            response_msg_cont = ' "' + user_msg_start + '" '
+        else:
+            response_msg_cont = " "
+        response_msg = f"Sorry, your message{response_msg_cont}is too old. Please send a new message."
+        background_tasks.add_task(
+            user_presenter.send_whatsapp_message,
+            response_msg,
+        )
+        return Response(status_code=200)
+
     # Check if the incoming message is a location
     if incoming_msg_type == "location":
         # NOTE: Currently, will not handle location messages

src/ansari/presenters/whatsapp_presenter.py

@@ -32,6 +32,7 @@ def __init__(
         incoming_msg_type: str | None = None,
         incoming_msg_body: dict | None = None,
         message_id: str | None = None,
+        message_unix_time: int | None = None,
     ):
         if agent:
             self.settings = agent.settings
@@ -48,6 +49,7 @@ def __init__(
         self.incoming_msg_type = incoming_msg_type
         self.incoming_msg_body = incoming_msg_body
         self.message_id = message_id
+        self.message_unix_time = message_unix_time
         self.typing_indicator_task = None
         self.first_indicator_time = None
 
@@ -59,6 +61,7 @@ def create_user_specific_presenter(
         incoming_msg_type: str,
         incoming_msg_body: dict,
         message_id: str,
+        message_unix_time: int | None = None,
     ):
         """Creates a user-specific presenter instance from a general presenter."""
         return cls(
@@ -69,20 +72,22 @@ def create_user_specific_presenter(
             incoming_msg_type=incoming_msg_type,
             incoming_msg_body=incoming_msg_body,
             message_id=message_id,
+            message_unix_time=message_unix_time,
         )
 
     async def extract_relevant_whatsapp_message_details(
         self,
         body: dict[str, Any],
-    ) -> tuple[bool, str | None, str | None, dict | None, str | None]:
+    ) -> tuple[bool, str | None, str | None, dict | None, str | None, int | None]:
         """Extracts relevant whatsapp message details from the incoming webhook payload.
 
         Args:
             body (Dict[str, Any]): The JSON body of the incoming request.
 
         Returns:
-            tuple[bool, Optional[str], Optional[str], Optional[dict], Optional[str]]:
-                A tuple of (is_status, user_whatsapp_number, incoming_msg_type, incoming_msg_body, message_id)
+            tuple[bool, Optional[str], Optional[str], Optional[dict], Optional[str], Optional[int]]:
+                A tuple of:
+                (is_status, user_whatsapp_number, incoming_msg_type, incoming_msg_body, message_id, message_unix_time)
 
         Raises:
             Exception: If the payload structure is invalid or unsupported.
@@ -109,7 +114,7 @@ async def extract_relevant_whatsapp_message_details(
             # logger.debug(
             #     f"WhatsApp status update received:\n({status} at {timestamp}.)",
             # )
-            return True, None, None, None, None
+            return True, None, None, None, None, None
         else:
             is_status = False
 
@@ -127,6 +132,9 @@ async def extract_relevant_whatsapp_message_details(
         message_id = incoming_msg.get("id")
         # Extract the phone number of the WhatsApp sender
         user_whatsapp_number = incoming_msg["from"]
+        # Extract timestamp from message (in Unix time format) and convert to int if present
+        message_unix_time_str = incoming_msg.get("timestamp")
+        message_unix_time = int(message_unix_time_str) if message_unix_time_str is not None else None
         # Meta API note: Meta sends "errors" key when receiving unsupported message types
         # (e.g., video notes, gifs sent from giphy, or polls)
         incoming_msg_type = incoming_msg["type"] if incoming_msg["type"] in incoming_msg.keys() else "errors"
@@ -135,7 +143,7 @@ async def extract_relevant_whatsapp_message_details(
 
         logger.info(f"Received a supported whatsapp message from {user_whatsapp_number}: {incoming_msg_body}")
 
-        return (is_status, user_whatsapp_number, incoming_msg_type, incoming_msg_body, message_id)
+        return (is_status, user_whatsapp_number, incoming_msg_type, incoming_msg_body, message_id, message_unix_time)
 
     async def check_and_register_user(self) -> bool:
         """
@@ -795,5 +803,50 @@ async def handle_unsupported_message(
             f"Sorry, I can't process {msg_type} yet. Please send me a text message.",
         )
 
+    def is_message_too_old(self) -> bool:
+        """
+        Checks if the incoming message is older than the allowed threshold (24 hours).
+
+        Uses the message_unix_time attribute (timestamp in Unix time format - seconds since epoch)
+        extracted during message processing to determine if the message is too old.
+
+        Returns:
+            bool: True if the message is older than 24 hours, False otherwise
+        """
+        # Define the too old threshold (24 hours in seconds)
+        TOO_OLD_THRESHOLD = 24 * 60 * 60  # 24 hours in seconds
+
+        # If there's no timestamp, message can't be verified as too old
+        if not self.message_unix_time:
+            logger.debug("No timestamp available, cannot determine message age")
+            return False
+
+        # Convert the Unix timestamp to a datetime object
+        try:
+            msg_time = datetime.fromtimestamp(self.message_unix_time, tz=timezone.utc)
+            # Get the current time in UTC
+            current_time = datetime.now(timezone.utc)
+            # Calculate time difference in seconds
+            time_diff = (current_time - msg_time).total_seconds()
+
+            # Log the message age for debugging
+            if time_diff < 60:
+                age_logging = f"{time_diff:.1f} seconds"
+            elif time_diff < 3600:
+                age_logging = f"{time_diff / 60:.1f} minutes"
+            elif time_diff < 86400:
+                age_logging = f"{time_diff / 3600:.1f} hours"
+            else:
+                age_logging = f"{time_diff / 86400:.1f} days"
+
+            logger.debug(f"Message age: {age_logging}")
+
+            # Return True if the message is older than the threshold
+            return time_diff > TOO_OLD_THRESHOLD
+
+        except (ValueError, TypeError) as e:
+            logger.error(f"Error parsing message timestamp: {e}")
+            return False
+
     def present(self):
         pass