Advanced Search Filters for Classroom Management

Understanding Advanced Search Requirements

Imagine you're a school administrator trying to find classrooms that match specific criteria. You might need to find all classrooms with "Mr." in the name, or all classrooms that can accommodate between 25-30 students. These are the kinds of flexible search capabilities we'll implement in this phase.

Implementing Name Pattern Matching

Let's start with implementing the classroom name search. This is similar to how you might search for a contact in your phone - partial matches should work.

const { Op } = require('sequelize');

const getClassrooms = async (req, res) => {
    try {
        const { name } = req.query;
        const whereClause = {};
        
        // Add name filter if provided
        if (name) {
            whereClause.name = {
                [Op.like]: `%${name}%`
            };
        }
        
        const classrooms = await Classroom.findAll({
            where: whereClause,
            order: [['name', 'ASC']]
        });
        
        res.json(classrooms);
    } catch (error) {
        console.error('Error in classroom search:', error);
        res.status(500).json({
            error: 'Failed to search classrooms'
        });
    }
};

Implementing Student Limit Range Search

Now let's implement the ability to search for classrooms based on their student capacity. This is more complex because we need to handle both exact matches and ranges.

const handleStudentLimitFilter = (studentLimit) => {
    if (!studentLimit) return null;
    
    // Check if it's a range query (contains comma)
    if (studentLimit.includes(',')) {
        const [min, max] = studentLimit.split(',').map(Number);
        
        // Validate the range values
        if (isNaN(min) || isNaN(max)) {
            throw new Error('Student Limit should be two numbers: min,max');
        }
        
        if (min > max) {
            throw new Error('Minimum limit cannot be greater than maximum limit');
        }
        
        return {
            [Op.between]: [min, max]
        };
    }
    
    // Handle exact match
    const limit = Number(studentLimit);
    if (isNaN(limit)) {
        throw new Error('Student Limit should be an integer');
    }
    
    return limit;
};

const getClassroomsWithFilters = async (req, res) => {
    try {
        const { name, studentLimit } = req.query;
        const whereClause = {};
        
        // Add name filter if provided
        if (name) {
            whereClause.name = {
                [Op.like]: `%${name}%`
            };
        }
        
        // Add student limit filter if provided
        if (studentLimit) {
            try {
                const limitFilter = handleStudentLimitFilter(studentLimit);
                if (limitFilter) {
                    whereClause.studentLimit = limitFilter;
                }
            } catch (error) {
                return res.status(400).json({
                    errors: [{ message: error.message }],
                    count: 0,
                    pageCount: 0
                });
            }
        }
        
        const classrooms = await Classroom.findAll({
            where: whereClause,
            order: [['name', 'ASC']]
        });
        
        res.json(classrooms);
    } catch (error) {
        console.error('Error in classroom search:', error);
        res.status(500).json({
            error: 'Failed to search classrooms'
        });
    }
};

Handling Complex Search Scenarios

Let's look at how our implementation handles different search scenarios:

GET /classrooms?name=mr

GET /classrooms?studentLimit=25

GET /classrooms?studentLimit=20,30

GET /classrooms?name=mr&studentLimit=20,30

Error Handling and Edge Cases

Proper error handling is crucial for a robust search system. Let's look at how we handle various edge cases:

const validateSearchParams = (params) => {
    const errors = [];
    
    if (params.studentLimit) {
        if (params.studentLimit.includes(',')) {
            const [min, max] = params.studentLimit.split(',').map(Number);
            if (isNaN(min) || isNaN(max)) {
                errors.push('Student Limit should be two numbers: min,max');
            } else if (min > max) {
                errors.push('Minimum limit cannot be greater than maximum limit');
            }
        } else {
            const limit = Number(params.studentLimit);
            if (isNaN(limit)) {
                errors.push('Student Limit should be an integer');
            }
        }
    }
    
    return errors;
};

Best Practices and Performance Considerations

Practical Applications

This search functionality enables several important administrative tasks:

Exercise: Extended Search Features