Streamlining Student Interaction with TutorController in JavaScript

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 in JavaScript. JavaScript// Import the crypto library for generating unique identifiers import crypto from 'crypto'; // Import the TutorService class import TutorService from './services/tutor_service.js'; class TutorController { constructor() { this.tutorService = new TutorService(); this.testSession = {}; // Simple session storage for testing } } In this snippet, we: Import the Node.js built-in crypto library for generating unique identifiers. Import the TutorService class for managing tutoring data and processing student queries. Initialize the TutorController with an instance of TutorService. Create a testSession object to simulate session management for testing purposes. The testSession object is a simple in-memory store used to simulate session management for testing. It allows us 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 testSession, 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

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 sendQuery method is responsible for processing student queries and returning the tutor's response or an error message.

JavaScript

async sendQuery(sessionId = null, studentQuery = null) {
    // Handle tutoring query sending request
    const studentId = this.testSession.studentId;
    if (!studentId) {
        return this._errorResponse('Session expired', 401);
    }

    if (!sessionId || !studentQuery) {
        return this._errorResponse('Missing sessionId or query', 400);
    }

    try {
        const tutorResponse = await this.tutorService.processQuery(
            studentId,
            sessionId,
            studentQuery
        );
        return this._successResponse({ message: tutorResponse });
    } catch (err) {
        if (err instanceof Error && err.name === 'ValueError') {
            return this._errorResponse(err.message, 404);
        } else if (err instanceof Error && err.name === 'RuntimeError') {
            return this._errorResponse(err.message, 500);
        } else {
            return this._errorResponse('An unexpected error occurred', 500);
        }
    }
}

async sendQuery(sessionId = null, studentQuery = null) {
    // Handle tutoring query sending request
    const studentId = this.testSession.studentId;
    if (!studentId) {
        return this._errorResponse('Session expired', 401);
    }

    if (!sessionId || !studentQuery) {
        return this._errorResponse('Missing sessionId or query', 400);
    }

    try {
        const tutorResponse = await this.tutorService.processQuery(
            studentId,
            sessionId,
            studentQuery
        );
        return this._successResponse({ message: tutorResponse });
    } catch (err) {
        if (err instanceof Error && err.name === 'ValueError') {
            return this._errorResponse(err.message, 404);
        } else if (err instanceof Error && err.name === 'RuntimeError') {
            return this._errorResponse(err.message, 500);
        } else {
            return this._errorResponse('An unexpected error occurred', 500);
        }
    }
}

In this method:

We first check if the student session is valid by retrieving the studentId from the testSession. If no studentId is found, we return an error response with a 401 status code.
We then validate that both sessionId and studentQuery 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 processQuery method of the TutorService. This method takes the studentId, sessionId, and studentQuery as parameters. Since this is an asynchronous operation, we use await.
If the query is processed successfully, we return the tutor's response in a success response format.
If a ValueError 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.
For any other unexpected errors, we return a generic 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.

JavaScript

// Import the TutorController class
import TutorController from './controllers/tutor_controller.js';

// Initialize the TutorController
const tutorController = new TutorController();

// Ensure a student session for testing
const studentId = tutorController.ensureStudentSession();

// Create a new tutoring session
const sessionResponse = tutorController.createSession();

if (sessionResponse.status === 'error') {
    const errorData = sessionResponse.error;
    console.log(`Error ${errorData.code}: ${errorData.message}`);
} else {
    const sessionData = sessionResponse.data;
    const sessionId = sessionData.sessionId;
    console.log(`Tutoring session created with sessionId: ${sessionId}`);

    // Example query handling
    const studentQuery = "What are the key differences between mitosis and meiosis?";

    tutorController.sendQuery(sessionId, studentQuery)
        .then(response => {
            if (response.status === 'error') {
                const errorData = response.error;
                console.log(`Error ${errorData.code}: ${errorData.message}`);
            } else {
                console.log(`Tutor Response: ${response.data.message}`);
            }
        });
}

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 sendQuery 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.