Managing Controller Logic

Welcome to the next step in our journey of building a personal tutor service with DeepSeek models. In the previous lesson, we explored the TutorService struct, which acts as a bridge between managing tutoring session data and generating AI responses.

Now, we will focus on the TutorController, a crucial component that manages tutoring sessions and handles student queries by interacting with both the model and service layers. The controller is responsible for orchestrating the flow of data between the student interface and the backend services, ensuring that student interactions are processed efficiently and effectively.

The TutorController struct is the heart of our controller layer. It is responsible for managing tutoring sessions and processing student queries. Here is how the struct is defined:

pub struct TutorController {
    tutor_service: TutorService,
    test_session: HashMap<String, String>,
}

This struct contains a TutorService instance and a test_session map to simulate session management for testing purposes. The test_session is a simple HashMap used to mimic the behavior of student sessions typically managed by a web application or browser. In a real-world scenario, student sessions help track individual students 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 TutorController 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 when developing our RESTful API.

Next, let's look at the implementation block for TutorController, which includes the constructor and other methods:

impl TutorController {
    pub fn new() -> Self {
        let mut tc = TutorController {
            tutor_service: TutorService::new(),
            test_session: HashMap::new(),
        };
        tc.ensure_student_session();
        tc
    }
    // ... (other methods)
}

In the new constructor, we initialize the TutorService and the test_session map, and immediately ensure a student session is created. This setup allows us to simulate session management and focus on the controller's core logic.

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

pub fn ensure_student_session(&mut self) -> String {
    self.test_session
        .entry("student_id".to_string())
        .or_insert_with(|| Uuid::new_v4().to_string())
        .clone()
}

This method ensures that a student session is available by checking the test_session map for a student ID using the key "student_id". This is a hardcoded key used to store and retrieve the student's unique identifier in our session map. If no entry exists for this key, a new student ID is generated using Uuid::new_v4() and stored in the session. The method then returns the student ID, either the newly created one or the existing one.

In a production environment with multiple students, you would typically use a more sophisticated session management system, but for our testing purposes, this approach allows us to simulate a single student session effectively.

One of the primary responsibilities of the TutorController is to create new tutoring sessions. The create_session method handles session creation requests and makes use of helper methods for formatting responses, which we'll take a look at a bit later in this lesson.

pub fn create_session(&mut self) -> Value {
    let student_id = match self.test_session.get("student_id") {
        Some(id) => id.clone(),
        None => return Self::session_expired(),
    };

    let session_id = self.tutor_service.create_session(&student_id);
    Self::success_response(json!({
        "session_id": session_id,
        "message": "Tutoring session created successfully"
    }))
}

In this method:

1. Retrieve the student_id: We first check the test_session for a student_id.
2. Handle Session Expiry: If the session has expired (i.e., no student_id is found), we return an error response using our helper method session_expired. This approach ensures that the client can handle the error gracefully, providing a better user experience.
3. Create a Tutoring Session: If the session is valid, we call the create_session method of the TutorService with the student ID to create a new tutoring session. We then return a success response containing a unique session ID and a success message using our helper method success_response.

The send_query method is responsible for processing student queries and returning the tutor's response or an error message.

pub async fn send_query(
    &mut self,
    session_id: Option<&str>,
    student_query: Option<&str>,
) -> Value {
    let student_id = match self.test_session.get("student_id") {
        Some(id) => id.clone(),
        None => return Self::session_expired(),
    };

    let (sid, qry) = match (session_id, student_query) {
        (Some(s), Some(q)) => (s, q),
        _ => return Self::error_response("Missing session_id or query", 400),
    };

    match self.tutor_service.process_query(&student_id, sid, qry).await {
        Ok(resp) => Self::success_response(json!({ "message": resp })),
        Err(e) => {
            let code = if e.to_string().contains("Session not found") {
                404
            } else {
                500
            };
            Self::error_response(e.to_string(), code)
        }
    }
}

In this method:

1. We first check if the student session is valid by retrieving the student_id from the test_session. If no student_id is found, we return an error response with a 401 status code.
2. We then validate that both session_id and student_query are provided. If either is missing, we return an error response with a 400 status code.
3. If all validations pass, we attempt to process the query using the process_query method of the TutorService. This method takes the student_id, session_id, and student_query as parameters.
4. If the query is processed successfully, we return the tutor's response in a success response format.
5. If an error occurs (such as a missing session), we map the error to a 404 or 500 status code and return an error response.

The TutorController includes helper methods for formatting responses: success_response, error_response, and session_expired. These methods ensure consistent response formats throughout the controller.

fn success_response<T: serde::Serialize>(data: T) -> Value {
    json!({
        "status": "success",
        "data": data
    })
}

fn error_response(message: impl AsRef<str>, code: u16) -> Value {
    json!({
        "status": "error",
        "error": { "message": message.as_ref(), "code": code }
    })
}

fn session_expired() -> Value {
    Self::error_response("Session expired", 401)
}

These methods create standardized response formats:

• success_response returns a JSON object with a status field set to "success" and a data field containing the provided data.
• error_response returns a JSON object with a status field set to "error" and an error field with message and code details.
• session_expired is a convenience method for returning a session expiration error.

To see the TutorController in action, let's integrate it into the main application. This example demonstrates how to create a tutoring session and handle a student query, showcasing the controller's functionality.

mod session;
mod controller;
mod service;

use anyhow::Result;
use crate::controller::TutorController;

#[tokio::main]
async fn main() -> Result<()> {
    let mut tutor_controller = TutorController::new();

    let student_id = tutor_controller.ensure_student_session();
    println!("Student ID: {}", student_id);

    let session_response = tutor_controller.create_session();

    if session_response["status"] == "error" {
        println!("Error: {}", session_response["error"]["message"]);
        return Ok(());
    }

    let session_id = session_response["data"]["session_id"].as_str().unwrap();
    println!("Session created: {}", session_id);

    let student_query = "What are the key differences between mitosis and meiosis?";

    let response = tutor_controller
        .send_query(Some(session_id), Some(student_query))
        .await;

    if response["status"] == "error" {
        println!("Error: {}", response["error"]["message"]);
    } else {
        println!("Tutor Response: {}", response["data"]["message"]);
    }

    Ok(())
}

In this example, we first initialize the TutorController. We ensure a student session is available for testing. We then create a new tutoring session and handle the response. If successful, we simulate a student query about the differences between mitosis and meiosis and use the send_query method to process it.

The response is checked for errors, and either the error message or the tutor's response is printed. This example demonstrates the flow from ensuring a student session to creating a tutoring session and handling a student query, highlighting the controller's role in managing interactions.

In this lesson, we explored the TutorController struct and its role in managing tutoring sessions and handling student queries. We learned how to implement the controller, create tutoring sessions, and process student questions using the TutorService. The controller is a vital component of our personal tutor application, ensuring that student interactions are managed efficiently and effectively.

As you move on to the practice exercises, take the opportunity to experiment with the TutorController'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!