add source files and do direct translation to es6 for ch7, q2

Author: AmmarCSE

src/chapter7/q2/Call.js

@@ -0,0 +1,44 @@
+export class Call {
+	constructor(c) {
+        /* Minimal rank of employee who can handle this call. */
+        this.rank = Rank.Responder();
+
+        /* Person who is calling. */
+        this.caller = c;
+
+        /* Employee who is handling call. */
+        this.handler;
+	}
+
+	/* Set employee who is handling call. */
+	setHandler(e) {
+		this.handler = e;
+	}
+
+	/* Play recorded message to the customer. */
+	reply(message) {
+		console.log(message);
+	}
+
+	getRank() {
+		return this.rank;
+	}
+
+	setRank(r) {
+		this.rank = r;
+	}
+
+	incrementRank() {
+		if (this.rank == Rank.Responder()) {
+			this.rank = Rank.Manager();
+		} else if (this.rank == Rank.Manager()) {
+			this.rank = Rank.Director();
+		}
+		return this.rank;
+	}
+
+	/* Disconnect call. */
+	disconnect() {
+		this.reply("Thank you for calling");
+	}
+}

src/chapter7/q2/CallHandler.js

@@ -0,0 +1,93 @@
+/* CallHandler represents the body of the program,
+ * and all calls are funneled first through it. 
+ */
+
+/* We have 3 levels of employees: respondents, managers, directors. */
+const LEVELS = 3; 
+
+/* Initialize with 10 respondents, 4 managers, and 2 directors. */
+const NUM_RESPONDENTS = 10;
+const NUM_MANAGERS = 4;
+const NUM_DIRECTORS = 2;
+
+export class CallHandler {	
+    constructor() {
+        /* List of employees, by level.
+         * employeeLevels[0] = respondents
+         * employeeLevels[1] = managers
+         * employeeLevels[2] = directors
+         */
+    	this.employeeLevels = new Array(LEVELS);
+        /* queues for each call�s rank */
+    	this.callQueues = new Array(LEVELS); 
+    	
+        // Create respondents.
+        let respondents = new Array(NUM_RESPONDENTS);
+        for (let k = 0; k < NUM_RESPONDENTS - 1; k++) {
+            respondents.push(new Respondent(this));
+        }
+        this.employeeLevels[0] = respondents;
+
+        // Create managers.
+        let managers = new Array(NUM_MANAGERS);
+        managers.push(new Manager(this));
+        this.employeeLevels[1] = managers;
+
+        // Create directors.
+        let directors = new Array(NUM_DIRECTORS);
+        directors.push(new Director(this));
+        this.employeeLevels[2] = directors;
+    }
+    
+    /* Gets the first available employee who can handle this call. */
+    getHandlerForCall(call) {
+        for (let level = call.getRank().getValue(); level < LEVELS - 1; level++) {
+            let employeeLevel = this.employeeLevels[level];
+            for (let emp of employeeLevel) {
+                if (emp.isFree()) {
+                    return emp;
+                }
+            }
+        }
+        return null;
+    }
+
+    /* Routes the call to an available employee, or saves in a queue if no employee available. */
+    dispatchCall(caller) {
+    	let call = new Call(caller);
+    	dispatchCall(call);
+    }
+    
+    /* Routes the call to an available employee, or saves in a queue if no employee available. */
+    public void dispatchCall(Call call) {
+    	/* Try to route the call to an employee with minimal rank. */
+        Employee emp = getHandlerForCall(call);
+        if (emp != null) {
+        	emp.receiveCall(call);
+        	call.setHandler(emp);
+        } else {
+	        /* Place the call into corresponding call queue according to its rank. */
+	        call.reply("Please wait for free employee to reply");
+	        callQueues.get(call.getRank().getValue()).add(call);
+        }
+    }    
+
+    /* An employee got free. Look for a waiting call that he/she can serve. Return true
+     * if we were able to assign a call, false otherwise. */
+    assignCall(emp) {
+        /* Check the queues, starting from the highest rank this employee can serve. */
+        for (let rank = emp.getRank().getValue(); rank >= 0; rank--) {
+            let que = this.callQueues[rank];
+            
+            /* Remove the first call, if any */
+            if (que.length) {
+	            let call = que.shift(); 
+	            if (call != null) {
+	                emp.receiveCall(call);
+	                return true;
+	            }
+            }
+        }
+        return false;
+    }
+}

src/chapter7/q2/Caller.js

@@ -0,0 +1,6 @@
+export class Caller {
+	constructor(id, nm) {
+		this.name = nm;
+		this.userId = id;
+	}
+}

src/chapter7/q2/Director.js

@@ -0,0 +1,6 @@
+export class Director extends Employee {
+    constructor(callHandler) {
+    	super(callHandler);
+    	this.rank = Rank.Director();
+    }
+}

src/chapter7/q2/Employee.js

@@ -0,0 +1,65 @@
+/* Employee is a super class for the Director, Manager, and Respondent classes. It is implemented as an
+ * abstract class, since there should be no reason to instantiated an Employee type directly.
+ */
+class Employee {
+	public Employee(CallHandler handler) {
+        this.currentCall = null;
+        this.rank;
+
+		this.callHandler = handler;
+	}
+
+	/* Start the conversation */
+	receiveCall(call) {
+		this.currentCall = call;
+	}
+
+	/* the issue is resolved, finish the call */
+	callCompleted() {
+		if (this.currentCall != null) {
+			/* Disconnect the call. */
+			this.currentCall.disconnect();
+
+			/* Free the employee */
+			this.currentCall = null;
+		}
+
+		/* Check if there is a call waiting in queue */
+		this.assignNewCall();
+	}
+
+	/*
+	 * The issue has not been resolved. Escalate the call, and assign a new call
+	 * to the employee.
+	 */
+	escalateAndReassign() {
+		if (this.currentCall != null) {
+			/* esthis.calate call */
+			this.currentCall.incrementRank();
+			this.callHandler.dispatchCall(currentCall);
+
+			/* free the employee */
+			this.currentCall = null;
+		}
+
+		/* assign a new call */
+		this.assignNewCall();
+	}
+
+	/* Assign a new call to an employee, if the employee is free. */
+	assignNewCall() {
+		if (!this.isFree()) {
+			return false;
+		}
+		return this.callHandler.assignCall(this);
+	}
+
+	/* Returns whether or not the employee is free. */
+	isFree() {
+		return this.currentCall == null;
+	}
+
+	getRank() {
+		return this.rank;
+	}
+}

src/chapter7/q2/Manager.js

@@ -0,0 +1,6 @@
+export class Manager extends Employee {
+    constructor(callHandler) {
+    	super(callHandler);
+    	this.rank = Rank.Manager();
+    }
+}

src/chapter7/q2/Rank.js

@@ -0,0 +1,33 @@
+export class Rank {
+	Responder (0),
+	Manager (1),
+	Director (2);
+	
+	private int value;
+	
+	private Rank(int v) {
+		value = v;
+	}
+	
+	public int getValue() {
+		return value;
+	}
+}
+export const Rank = {
+    value: undefined,
+	Responder : () => {
+        this.value = 0; 
+        return this.value;
+    },
+	Manager : () => {
+        this.value = 1; 
+        return this.value;
+    },
+	Director : () => {
+        this.value = 2; 
+        return this.value;
+    },
+	getValue() {
+		return this.value;
+	}
+}

src/chapter7/q2/Respondent.js

@@ -0,0 +1,6 @@
+export class Respondent extends Employee {
+    constructor(callHandler) {
+    	super(callHandler);
+    	this.rank = Rank.Responder();
+    }
+}

src/chapter7/q2/ch7-q2.js

@@ -0,0 +1 @@
+new CallHandler();