In this lesson, we will focus on how to manage student interactions in our personal tutor service using function-based views. In the previous lesson, we built the TutorService class, which connects session management with the DeepSeek model to process student queries. Now, we will see how to orchestrate the flow of data between the frontend and backend using views. These views act as request handlers, receiving HTTP requests from the frontend, interacting with the service layer, and returning JSON responses. This approach ensures that student interactions are processed efficiently and according to the conventions of our web framework.

Instead of using a controller class, we define function-based views that handle specific actions, such as creating a tutoring session or processing a student query. Each view receives an HTTP request, interacts with the TutorService, and returns a JSON response.

Let's look at how to set up these views in our application:

Here, we import the necessary modules and initialize the TutorService. The views will use this service to manage sessions and process queries.

Before handling any tutoring session, we need to ensure that a student session exists. In our web framework, session data is managed using the request object. We can access and set session data using request.session, which is a dictionary-like object tied to each user's session.

This function checks if a student_id is present in the session. If not, it generates a new unique ID and stores it in the session. This ensures that each student has a unique identifier for their interactions.

To create a new tutoring session, we define a function-based view that handles HTTP POST requests. This view validates the session and returns a JSON response with the new session ID.

In this view:

1. We ensure the student session exists and retrieve the student_id.
2. We call the create_session method of the TutorService to create a new tutoring session.
3. We return a JSON response containing the new session ID and a success message.

To process student queries, we define another function-based view. This view receives the session ID and query from the request body, processes the query using the service layer, and returns the tutor's response or an error message as JSON.

In this view:

1. We ensure the student session exists and retrieve the student_id.
2. We parse the request body to get the session_id and student_query.
3. We process the query using the process_query method of the TutorService.
4. If successful, we return the tutor's response as JSON.
5. If an error occurs (such as an invalid session ID), we return an error message with the appropriate HTTP status code.

To use these views, we define URL patterns that map HTTP endpoints to the corresponding view functions. This allows the frontend to interact with the backend by sending HTTP requests to these endpoints.

Now, let's see how to interact with these endpoints using HTTP requests. The following example demonstrates how to create a tutoring session and send a query to the tutor:

In this example:

1. We establish a session with the backend.
2. We create a new tutoring session by sending a POST request to the /api/create_session/ endpoint.
3. If successful, we send a student query to the /api/send_query/ endpoint.

In this lesson, we learned how to manage student interactions using function-based views. We saw how to ensure student sessions, create new tutoring sessions, and process student queries by interacting with the service layer. These views act as the bridge between the frontend and backend, handling HTTP requests and returning JSON responses. As you move on to the practice exercises, try experimenting with these views and endpoints to reinforce your understanding of how data flows through the application. Great job, and keep building your skills!