Streamlining Student Interaction with TutorController in Ruby

Streamlining Student Interaction with Tutor Controller

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 class, 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.

Implementing the TutorController Class

The TutorController class is the heart of our controller layer. It is responsible for managing tutoring sessions and processing student queries. Let's begin by examining the structure of the TutorController class. Rubyrequire 'securerandom' require_relative '../services/tutor_service' class TutorController def initialize @tutor_service = TutorService.new @test_session = {} # Simple session storage for testing end end In this snippet, we: Use require 'securerandom' from Ruby's standard library for generating unique identifiers. Use require_relative to import the TutorService class for managing tutoring data and processing student queries. Initialize the TutorController with an instance of TutorService. Create an instance variable @test_session as a hash to simulate session management for testing purposes. The @test_session hash is used to mimic the behavior of student sessions typically managed by a web application. In a real-world scenario, student sessions help track individual students as they interact with an 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.

Ensuring Student Session

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 @test_session . If not, it generates a new student ID. Ruby # Ensure the student has a session ID in the test session. def ensure_student_session unless @test_session.key?(:student_id) @test_session[:student_id] = SecureRandom.uuid end @test_session[:student_id] end This method ensures that a student session is available by checking the @test_session hash for a :student_id key. If it doesn't exist, a new student ID is generated using SecureRandom.uuid and stored in the session. The method then returns the student ID, either the newly created one or the existing one.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Handling Student Queries

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

Ruby

# Handle tutoring query sending request.
def send_query(session_id: nil, student_query: nil)
  student_id = @test_session[:student_id]
  unless student_id
    return error_response('Session expired', 401)
  end

  if session_id.nil? || student_query.nil?
    return error_response('Missing session_id or query', 400)
  end

  begin
    tutor_response = @tutor_service.process_query(
      student_id: student_id,
      session_id: session_id,
      student_query: student_query
    )
    success_response(message: tutor_response)
  rescue ArgumentError => e
    error_response(e.message, 404)
  rescue RuntimeError => e
    error_response(e.message, 500)
  end
end

# Handle tutoring query sending request.
def send_query(session_id: nil, student_query: nil)
  student_id = @test_session[:student_id]
  unless student_id
    return error_response('Session expired', 401)
  end

  if session_id.nil? || student_query.nil?
    return error_response('Missing session_id or query', 400)
  end

  begin
    tutor_response = @tutor_service.process_query(
      student_id: student_id,
      session_id: session_id,
      student_query: student_query
    )
    success_response(message: tutor_response)
  rescue ArgumentError => e
    error_response(e.message, 404)
  rescue RuntimeError => e
    error_response(e.message, 500)
  end
end

In this method:

We first check if the student session is valid by retrieving the student_id from @test_session. If no student_id is found, we return an error response with a 401 status code. (The error_response helper method will be described in the next section.)
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.
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.
If the query is processed successfully, we return the tutor's response in a success response format using the success_response helper method. (Details of this helper method are provided in the next section.)
If an ArgumentError occurs (e.g., if the session ID doesn't exist), we return an error response with a 404 status code.
If a RuntimeError occurs (e.g., if there's an issue with the AI model), we return an error response with a 500 status code.

Integrating the Tutor Controller in the Main Application

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.

Ruby

require_relative './controllers/tutor_controller'

# Initialize the TutorController
tutor_controller = TutorController.new

# Ensure a student session for testing
student_id = tutor_controller.ensure_student_session

# Create a new tutoring session
session_response = tutor_controller.create_session

if session_response.is_a?(Array) && session_response[0][:status] == 'error'
  error_data = session_response[0][:error]
  puts "Error #{error_data[:code]}: #{error_data[:message]}"
else
  session_data = session_response[:data]
  session_id = session_data[:session_id]
  puts "Tutoring session created with session_id: #{session_id}"

  # Example query handling
  student_query = "What are the key differences between mitosis and meiosis?"

  response = tutor_controller.send_query(session_id: session_id, student_query: student_query)

  if response.is_a?(Array) && response[0][:status] == 'error'
    error_data = response[0][:error]
    puts "Error #{error_data[:code]}: #{error_data[:message]}"
  else
    puts "Tutor Response: #{response[:data][:message]}"
  end
end

require_relative './controllers/tutor_controller'

# Initialize the TutorController
tutor_controller = TutorController.new

# Ensure a student session for testing
student_id = tutor_controller.ensure_student_session

# Create a new tutoring session
session_response = tutor_controller.create_session

if session_response.is_a?(Array) && session_response[0][:status] == 'error'
  error_data = session_response[0][:error]
  puts "Error #{error_data[:code]}: #{error_data[:message]}"
else
  session_data = session_response[:data]
  session_id = session_data[:session_id]
  puts "Tutoring session created with session_id: #{session_id}"

  # Example query handling
  student_query = "What are the key differences between mitosis and meiosis?"

  response = tutor_controller.send_query(session_id: session_id, student_query: student_query)

  if response.is_a?(Array) && response[0][:status] == 'error'
    error_data = response[0][:error]
    puts "Error #{error_data[:code]}: #{error_data[:message]}"
  else
    puts "Tutor Response: #{response[:data][:message]}"
  end
end

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.