Welcome to the next step in our journey of building a chatbot service with Flask. In the previous lesson, we explored the ChatService class, which acts as a bridge between managing chat data and generating AI responses. Now, we will focus on the ChatController, a crucial component that manages chat sessions and handles messages by interacting with both the model and service layers. The controller is responsible for orchestrating the flow of data between the user interface and the backend services, ensuring that user interactions are processed efficiently and effectively.

The ChatController class is the heart of our controller layer. It is responsible for managing chat sessions and processing user messages. Let's begin by examining the structure of the ChatController class.

Python
Copy to clipboard
1import uuid
2from services.chat_service import ChatService
3
4class ChatController:
5    def __init__(self):
6        self.chat_service = ChatService()
7        self.test_session = {}

In this snippet, we:

• Import the uuid module from the Python standard library for generating unique identifiers.
• Use uuid to create distinct user and chat session IDs.
• Import the ChatService class for managing chat data and processing messages.
• Initialize the ChatController with an instance of ChatService.
• Use a test_session dictionary to simulate session management for testing purposes.

The test_session is a simple dictionary used to simulate session management for testing purposes. It allows us to mimic the behavior of user sessions typically managed by a web application or browser. In a real-world scenario, user sessions help track individual users as they interact with a web application, maintaining their state and data across multiple requests. By using test_session, we can focus on testing the core functionality of the ChatController without needing a full session management system. Once we are confident that the controller works correctly, we will later integrate a more robust session management solution using Flask's built-in session handling. This will provide a secure and scalable way to manage user sessions in a web application, ensuring that user data is maintained consistently across different interactions.

Before creating a chat, we need to ensure that a user session exists. The ensure_user_session method checks if a user ID is present in the test_session. If not, it generates a new user ID.

Python
Copy to clipboard
1def ensure_user_session(self):
2    """Ensure user has a session ID in the test session."""
3    if 'user_id' not in self.test_session:
4        self.test_session['user_id'] = str(uuid.uuid4())
5    return self.test_session['user_id']

This method ensures that a user session is available by checking the test_session dictionary for a user_id. If it doesn't exist, a new user ID is generated and stored in the session.

One of the primary responsibilities of the ChatController is to create new chat sessions. The create_chat method simulates a chat creation request.

Python
Copy to clipboard
1def create_chat(self):
2    """Handle chat creation request."""
3    user_id = self.test_session.get('user_id')
4    if not user_id:
5        return {'error': 'Session expired'}, 401
6    
7    chat_id = self.chat_service.create_chat(user_id)
8    return {
9        'chat_id': chat_id,
10        'message': 'Chat created successfully'
11    }

In this method, we:

1. Retrieve the user_id: We first check the test_session for a user_id.

2. Handle Session Expiry: If the session has expired (i.e., no user_id is found), we return an error response: {'error': 'Session expired'}, 401. Instead of raising an exception, we return an error response because this method will be part of an API endpoint. Returning an error response with an appropriate HTTP status code (such as 401 for unauthorized access) allows the API to communicate the issue clearly to the client. This approach ensures that the client can handle the error gracefully, providing a better user experience.

3. Create a Chat Session: If the session is valid, we call the create_chat method of the ChatService with the user ID to create a new chat session. We then return a response containing a unique chat ID and a success message: {'chat_id': chat_id, 'message': 'Chat created successfully'}.

The send_message method is responsible for processing user messages and returning the AI's response or an error message.

Python
Copy to clipboard
1def send_message(self, chat_id, user_message):
2    """Handle message sending request."""
3    user_id = self.test_session.get('user_id')
4    if not user_id:
5        return {'error': 'Session expired'}, 401
6    
7    if not chat_id or not user_message:
8        return {'error': 'Missing chat_id or message'}, 400
9        
10    try:
11        ai_response = self.chat_service.process_message(user_id, chat_id, user_message)
12        return {'message': ai_response}
13    except ValueError as e:
14        return {'error': str(e)}, 404
15    except RuntimeError as e:
16        return {'error': str(e)}, 500

In this method, we first check if the user session is valid. We then ensure that both chat_id and user_message are provided. If any are missing, an error is returned. The method attempts to process the message using the process_message method of the ChatService. If successful, the AI's response is returned. If an exception occurs, an appropriate error message is returned.

To see the ChatController in action, let's integrate it into the main application. This example demonstrates how to create a chat session and handle a user message, showcasing the controller's functionality.

Python
Copy to clipboard
1from controllers.chat_controller import ChatController
2
3# Initialize the ChatController
4chat_controller = ChatController()
5
6# Ensure a user session for testing
7user_id = chat_controller.ensure_user_session()
8
9# Create a new chat session
10chat_response = chat_controller.create_chat()
11
12# Handle chat creation response
13if 'error' in chat_response:
14    print(f"Error: {chat_response['error']}")
15else:
16    # Extract chat_id from the response and print the chat session details
17    chat_id = chat_response['chat_id']
18    print(f"Chat session created with chat_id: {chat_id}")
19
20    # Example message handling
21    user_message = "What are the support hours for the Basic Plan?"
22
23    # Send the user message and get the response
24    response = chat_controller.send_message(chat_id, user_message)
25
26    # Handle message response
27    if 'error' in response:
28        print(f"Error: {response['error']}")
29    else:
30        print(f"AI Response: {response['message']}")

In this example, we first initialize the ChatController. We ensure a user session is available for testing. We then create a new chat session and handle the response. If successful, we simulate a user message and use the send_message method to process it. The response is checked for errors, and either the error message or the AI's response is printed. This example demonstrates the flow from ensuring a user session to creating a chat session and handling a user message, highlighting the controller's role in managing interactions.

In this lesson, we explored the ChatController class and its role in managing chat sessions and handling user messages. We learned how to implement the controller, create chat sessions, and process messages using the ChatService. The controller is a vital component of our chatbot application, ensuring that user interactions are managed efficiently and effectively.

As you move on to the practice exercises, take the opportunity to experiment with the ChatController's functionality. This hands-on practice will reinforce the concepts covered in this lesson and prepare you for the next steps in our course. Keep up the great work, and I look forward to seeing your progress!