Wednesday, March 26, 2014

Design the classes and data structures for a call center

Imagine you have a call center with three levels of employees: fresher, technical lead (TL), product manager (PM). There can be multiple employees, but only one TL or PM. An incoming telephone call must be allocated to a fresher who is free. If a fresher can’t handle the call, he or she must escalate the call to technical lead. If the TL is not free or not able to handle it, then the call should be escalated to PM. Design the classes and data structures for this problem. Implement a method getCallHandler().
 All three ranks of employees have different work to be done, so those specific functions are profile specific. We should keep these specific things within their respective class.
There are a few things which are common to them, like address, name, job title, age, etc. These things can be kept in one class and can be extended / inherited by others.

Finally, there should be one CallHandler class which would route the calls to the concerned person.
NOTE: On any object oriented design question, there are many ways to design the objects. Discuss the trade-offs of different solutions with your interviewer. You should usually design for long term code flexibility and maintenance.
CallHandler class:
1. stores all employees in different levels
2. stores all calls in a Queue.
3. getCallHandler() returns a Employee who is suitable for accepting this call.
4. dispatchCall() gets a employeer from 3, then try ReceiveCall(), if return from 3 is null, put call in Queue.

Call class:
1. call have ranks.
2. call can be reply and disconnected.

Employee class:
1. Every Employee have a CallHandler
2. every Employee have a rank.
3. ReceiveCall()
4. CallHandled()
5. CannotHandle(), if can’t handle, handlerObj.dispatchCall(call) and handlerObj.getNextCall()
6. boolean free. is free or not.

 Lets see the class diagram:

You can download the detailed code here on github, but this is the code in java:

public class CallHandler {
    static final int LEVELS = 3; // we have 3 levels of employees
    static final int NUM_FRESHERS = 5; // we have 5 freshers no vars needed for TL and PM cuz only 1.
    ArrayList<Employee>[] employeeLevels = new ArrayList[LEVELS];
    // queues for each call’s rank
    Queue<Call>[] callQueues = new LinkedList[LEVELS];
    public CallHandler() { ... }
    Employee getCallHandler(Call call) {
        for (int level = call.rank; level < LEVELS - 1; level++) {
            ArrayList<Employee> employeeLevel = employeeLevels[level];
            for (Employee emp : employeeLevel) {
                if ( {
                    return emp;
        return null;
    // routes the call to an available employee, or adds to a queue
    void dispatchCall(Call call) {
        // try to route the call to an employee with minimal rank
        Employee emp = getCallHandler(call);
        if (emp != null) {
        } else {
            // place the call into queue according to its rank
    void getNextCall(Employee e) {...} // look for call for e’s rank
class Call {
    int rank = 0; // minimal rank of employee who can handle this call
    public void reply(String message) { ... }
    public void disconnect() { ... }

class Employee {
    CallHandler callHandler;
    int rank; // 0- fresher, 1 - technical lead, 2 - product manager
    boolean free;
    Employee(int rank) { this.rank = rank; }
    void ReceiveCall(Call call) { ... }
    void CallHandled(Call call) { ... } // call is complete
    void CannotHandle(Call call) { // escalate call
        call.rank = rank + 1;
        free = true;
        callHandler.getNextCall(this); // look for waiting call
class Fresher extends Employee {
    public Fresher() { super(0); } 
class TechLead extends Employee {
    public TechLead() { super(1); }
class ProductManager extends Employee {
    public ProductManager() { super(2); }


Post a Comment