test update rule

nbproject/private/private.xml

@@ -4,7 +4,9 @@
     <open-files xmlns="http://www.netbeans.org/ns/projectui-open-files/2">
         <group>
             <file>file:/C:/Users/nhuyt/OneDrive/Documents/NetBeansProjects/TurnControl/src/turncontrol/Employee.java</file>
+            <file>file:/C:/Users/nhuyt/OneDrive/Documents/NetBeansProjects/TurnControl/src/turncontrol/test1.java</file>
             <file>file:/C:/Users/nhuyt/OneDrive/Documents/NetBeansProjects/TurnControl/src/turncontrol/TurnControl.java</file>
+            <file>file:/C:/Users/nhuyt/OneDrive/Documents/NetBeansProjects/TurnControl/src/turncontrol/BubbleSort.java</file>
         </group>
     </open-files>
 </project-private>

src/turncontrol/BubbleSort.java

@@ -17,44 +17,75 @@ public class BubbleSort {
 
     public void bubbleSortTime(ArrayList<Employee> employee) {
         int n = employee.size();
+        System.out.println("BEFORE bubbleSortTime:");
+        printEmployeeName(employee);
         for (int i = 0; i < n - 1; i++) {
             for (int j = 0; j < n - i - 1; j++) {
-                if (employee.get(i).getCheckInTime().isAfter(employee.get(i + 1).getCheckInTime())) {
-                    Collections.swap(employee, i, i + 1);
+                if (employee.get(j).getCheckInTime().isAfter(employee.get(j + 1).getCheckInTime())) {
+                    System.out.print("<<IS_AFTER>>");
+                    Collections.swap(employee, j, j + 1);
                 }
             }
+            System.out.println("bubbleSortTime-SORT ROUND " + (i + 1));
         }
+        System.out.println("AFTER bubbleSortTime:");
+        printEmployeeName(employee);
     }
 
     public void bubbleSortTotal(ArrayList<Employee> employee) {
         int n = employee.size();
+        System.out.println("BEFORE bubbleSortTotal:");
+        printEmployeeName(employee);
         for (int i = 0; i < n - 1; i++) {
             for (int j = 0; j < n - i - 1; j++) {
-                if (employee.get(i).getTotal() > employee.get(i + 1).getTotal()) {
-                    Collections.swap(employee, i, i + 1);
+                if (employee.get(j).getTotal() > employee.get(j + 1).getTotal()) {
+                    System.out.print("<<Larger>>");
+                    Collections.swap(employee, j, j + 1);
+                } else if (employee.get(j).getTotal() == employee.get(j + 1).getTotal()) {
+                    if (employee.get(j).getCheckInTime().isAfter(employee.get(j + 1).getCheckInTime())) {
+                        System.out.print("<<Is_After>>");
+                        Collections.swap(employee, j, j + 1);
+                    }
                 }
             }
+            System.out.println("bubbleSortTotal-SORT ROUND " + (i + 1));
         }
+        System.out.println("AFTER bubbleSortTotal:");
+        printEmployeeName(employee);
     }
 
     public void bubbleSortTotalTurn(ArrayList<Employee> employee) {
         int n = employee.size();
+        System.out.println("BEFORE bubbleSortTotalTurn:");
+        printEmployeeName(employee);
         for (int i = 0; i < n - 1; i++) {
             for (int j = 0; j < n - i - 1; j++) {
-                if (employee.get(i).getTotalTurn()> employee.get(i + 1).getTotalTurn()) {
-                    Collections.swap(employee, i, i + 1);
+                if (employee.get(j).getTotalTurn() > employee.get(j + 1).getTotalTurn()) {
+                    System.out.print("<<Larger>>");
+                    Collections.swap(employee, j, j + 1);
+                } else if (employee.get(j).getTotalTurn() == employee.get(j + 1).getTotalTurn()) {
+                    if (employee.get(j).getCheckInTime().isAfter(employee.get(j + 1).getCheckInTime())) {
+                        Collections.swap(employee, j, j + 1);
+                    }
                 }
             }
+            System.out.println("bubbleSortTotalTurn-SORT ROUND " + (i + 1));
+            printEmployeeList(employee);
         }
+        System.out.println("AFTER bubbleSortTotalTurn:");
+        printEmployeeName(employee);
     }
 
-    /* Prints the array */
-    public void printArray(int arr[]) {
-        int n = arr.length;
-        for (int i = 0; i < n; ++i) {
-            System.out.print(arr[i] + " ");
+    public static void printEmployeeList(ArrayList<Employee> e) {
+        for (int i = 0; i < e.size(); i++) {
+            System.out.println("Employee " + e.get(i).getEmpName() + " ----Total Turn " + e.get(i).getTotalTurn());
+        }
+    }
+
+    public static void printEmployeeName(ArrayList<Employee> e) {
+        for (int i = 0; i < e.size(); i++) {
+            System.out.println(e.get(i).getEmpName() + "\t" + e.get(i).getTotalTurn() + "\t"
+                    + e.get(i).getCheckInTime().toString());
         }
-        System.out.println();
     }
 }
-/* This code is contributed by Rajat Mishra */

src/turncontrol/Employee.java

@@ -23,11 +23,20 @@ public class Employee {
     int position;
     boolean active;
     boolean isWorking;
+    int indexGroup;
 
     Employee() {
         throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
     }
 
+    public int getIndexGroup() {
+        return indexGroup;
+    }
+
+    public void setIndexGroup(int indexGroup) {
+        this.indexGroup = indexGroup;
+    }
+
     public boolean isIsWorking() {
         return isWorking;
     }

src/turncontrol/TurnControl.java

@@ -3,12 +3,13 @@
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.Scanner;
 
 /**
  *
- * @author nhuytan
- * add collaborator lanhsunam987
+ * @author nhuytan add collaborator lanhsunam987
  */
 public class TurnControl {
 
@@ -25,8 +26,8 @@ public static void main(String[] args) {
         TableBuilder tbCommandGuide = new TableBuilder();
         tbCommandGuide.addRow("Enter Command: ", "=========", "=========");
         tbCommandGuide.addRow("1-Check In", "2-Check Out", "e-Exit Program");
-        tbCommandGuide.addRow("p-Print List", "3-Add Turn", "4-Remove Turn");
-        tbCommandGuide.addRow("5-Revert Working Status", "6-Update Turn", "----");
+        tbCommandGuide.addRow("3-Add Turn", "4-Remove Turn","5-Revert Working Status");
+        tbCommandGuide.addRow("6-Update Turn", "p-print");
         String commandGuide = tbCommandGuide.toString();
 
         while (true) {
@@ -376,12 +377,19 @@ public static void print(ArrayList<Employee> employee) {
         DateTimeFormatter dtf = DateTimeFormatter.ofPattern("HH:mm:ss");
         System.out.println("\nEmployee Table Details:");
         TableBuilder tb = new TableBuilder();
-        tb.addRow("EmployeeID", "EmployeeName", "CheckInTime", "Total", "Total_Turn", "Is_Working", "Status", "Position", "Turn_List");
+        tb.addRow("EmployeeID", "EmployeeName", "CheckInTime", "Total", "Total_Turn", "Is_Working", "Status", "Position", "Turn_List", "Index_Group");
         //System.out.println("EmployeeID\tEmployeeName\tCheckInTime\tTotal\tStatus\tPosition\n");
         for (int i = 0; i < employee.size(); i++) {
             int index = getIndexByValue(employee, i + 1);
             String turnList = getStringTurn(employee.get(index));
-            tb.addRow(employee.get(index).getEmployeeID(), employee.get(index).getEmpName(), dtf.format(employee.get(index).getCheckInTime()), Integer.toString(employee.get(index).getTotal()), Integer.toString(employee.get(index).getTotalTurn()), Boolean.toString(employee.get(index).isIsWorking()), Boolean.toString(employee.get(index).isActive()), Integer.toString(employee.get(index).position), turnList);
+            tb.addRow(employee.get(index).getEmployeeID(), employee.get(index).getEmpName(),
+                    dtf.format(employee.get(index).getCheckInTime()),
+                    Integer.toString(employee.get(index).getTotal()),
+                    Integer.toString(employee.get(index).getTotalTurn()),
+                    Boolean.toString(employee.get(index).isIsWorking()),
+                    Boolean.toString(employee.get(index).isActive()),
+                    Integer.toString(employee.get(index).position), turnList,
+                    Integer.toString(employee.get(index).getIndexGroup()));
         }
         System.out.println(tb.toString());
     }
@@ -426,7 +434,7 @@ public static void print(ArrayList<Employee> employee, boolean status) {
             TableBuilder tb = new TableBuilder();
             tb.addRow("EmployeeID", "EmployeeName", "CheckInTime", "Total", "Total_Turn", "Is_Working", "Status", "Position", "Turn_List");
             for (int i = 0; i < tmpInActive.size(); i++) {
-                int index = getIndexByValue(tmpInActive, employee.size()-tmpInActive.size() + 1);
+                int index = getIndexByValue(tmpInActive, employee.size() - tmpInActive.size() + 1);
                 String turnList = getStringTurn(tmpInActive.get(index));
                 tb.addRow(tmpInActive.get(index).getEmployeeID(),
                         tmpInActive.get(index).getEmpName(),
@@ -442,7 +450,7 @@ public static void print(ArrayList<Employee> employee, boolean status) {
         }
     }
 
-// HELP FUNCTIO - UPDATE POSITION BASE ON: TOTALTURN, CHECK-IN TIME
+// HELP FUNCTION - UPDATE POSITION BASE ON: TOTALTURN, CHECK-IN TIME
 /*
     Pseudo Code:
     1. Count number of member (active+inactive)
@@ -461,6 +469,8 @@ public static void updatePosition(ArrayList<Employee> employee) {
         int numberActive = 0;
         int numberInActive = 0;
         int numberBusyWorker = 0;
+        int numberFreeWorker = 0;
+        BubbleSort b = new BubbleSort();
         for (int i = 0; i < numberOfEmployee; i++) {
             if (employee.get(i).isActive()) {
                 numberActive++;
@@ -471,46 +481,99 @@ public static void updatePosition(ArrayList<Employee> employee) {
                 numberInActive++;
             }
         }
-// create tmp array of inactive and sort inactive & index  position       
-        ArrayList<Employee> tmpInActive = new ArrayList<>(numberInActive);
-        for (int i = 0; i < employee.size(); i++) {
-            if (employee.get(i).isActive() == false) {
-                tmpInActive.add(employee.get(i));
-            }
-        }
+        numberFreeWorker = numberActive - numberBusyWorker;
 
-        BubbleSort b = new BubbleSort();
-        b.bubbleSortTime(tmpInActive);
-
-        for (int i = 0; i < tmpInActive.size(); i++) {
-            tmpInActive.get(i).setPosition(i + 1 + numberActive);
+        //System.out.println("employee object address is: "+ employee.);
+//Create tmp array of inactive and sort inactive & index  position 
+//Process Inactive worker array
+        if (numberInActive > 0) {
+            ArrayList<Employee> tmpInActive = new ArrayList<>(numberInActive);
+            for (int i = 0; i < employee.size(); i++) {
+                if (employee.get(i).isActive() == false) {
+                    tmpInActive.add(employee.get(i));
+                }
+            }
+            b.bubbleSortTime(tmpInActive);
+            for (int i = 0; i < tmpInActive.size(); i++) {
+                tmpInActive.get(i).setPosition(i + 1 + numberActive);
+            }
         }
 // Create tmp array of busy worker and sort by total , index position
-        ArrayList<Employee> tmpBusyWorker = new ArrayList<>(numberBusyWorker);
-        for (int i = 0; i < employee.size(); i++) {
-            if (employee.get(i).isActive() && employee.get(i).isIsWorking()) {
-                tmpBusyWorker.add(employee.get(i));
+// Process Busy worker array
+        if (numberBusyWorker > 0) {
+            ArrayList<Employee> tmpBusyWorker = new ArrayList<>(numberBusyWorker);
+            for (int i = 0; i < employee.size(); i++) {
+                if (employee.get(i).isActive() && employee.get(i).isIsWorking()) {
+                    tmpBusyWorker.add(employee.get(i));
+                }
+            }
+            b.bubbleSortTotal(tmpBusyWorker);
+//set Position
+            for (int i = 0; i < tmpBusyWorker.size(); i++) {
+                tmpBusyWorker.get(i).setPosition(numberActive - numberBusyWorker + i + 1);
             }
-        }
-
-        b.bubbleSortTotal(tmpBusyWorker);
-
-        for (int i = 0; i < tmpBusyWorker.size(); i++) {
-            tmpBusyWorker.get(i).setPosition(numberActive - numberBusyWorker + i + 1);
         }
 // 9 active , 4 working, 2 inactive --> free = 5, busy =5, inactive =2        
 // Create active list and not busy, sort and index
-        ArrayList<Employee> tmpFreeWorker = new ArrayList<>(numberActive - numberBusyWorker);
-        for (int i = 0; i < employee.size(); i++) {
-            if (employee.get(i).isActive() && !employee.get(i).isIsWorking()) {
-                tmpFreeWorker.add(employee.get(i));
+// Process Free worker array
+
+        if (numberFreeWorker > 0) {
+            ArrayList<Employee> tmpFreeWorker = new ArrayList<>(numberFreeWorker);
+            for (int i = 0; i < employee.size(); i++) {
+                if (employee.get(i).isActive() && !employee.get(i).isIsWorking()) {
+                    tmpFreeWorker.add(employee.get(i));
+                }
             }
-        }
 
-        b.bubbleSortTotalTurn(tmpFreeWorker);
+            b.bubbleSortTotalTurn(tmpFreeWorker);
+//index group by Step_Turn
+            int tmpIndexGroup = 1;
+            if (tmpFreeWorker.size() > 0) {
+                tmpFreeWorker.get(0).setIndexGroup(tmpIndexGroup);
+                //System.out.println("Employee: " + tmpFreeWorker.get(0).getEmpName() + " total_Turn: " + tmpFreeWorker.get(0).getTotalTurn());
+                if (tmpFreeWorker.size() > 1) {
+                    for (int i = 1; i < tmpFreeWorker.size(); i++) {
+                        if ((tmpFreeWorker.get(i).getTotalTurn() - tmpFreeWorker.get(i - 1).getTotalTurn()) >= 15) {
+                            tmpIndexGroup++;
+                            tmpFreeWorker.get(i).setIndexGroup(tmpIndexGroup);
+                        } else {
+                            tmpFreeWorker.get(i).setIndexGroup(tmpIndexGroup);
+                        }
+                        //System.out.println("Employee: " + tmpFreeWorker.get(i).getEmpName() + " total_Turn: " + tmpFreeWorker.get(i).getTotalTurn());
+                    }
+                }
+            }
 
-        for (int i = 0; i < tmpFreeWorker.size(); i++) {
-            tmpFreeWorker.get(i).setPosition(i + 1);
+            ArrayList<ArrayList<Employee>> arraylist_employee = new ArrayList<ArrayList<Employee>>(tmpIndexGroup);
+            if (tmpFreeWorker.size() > 1) {
+                ArrayList<Employee> tmp = new ArrayList<Employee>();
+                tmp.add(tmpFreeWorker.get(0));
+                //int tmp = tmpFreeWorker.get(0).getIndexGroup();
+                for (int i = 1; i < tmpFreeWorker.size(); i++) {
+                    if (tmpFreeWorker.get(i).getIndexGroup() != tmpFreeWorker.get(i - 1).getIndexGroup()) {
+                        arraylist_employee.add(tmp);
+                        System.out.println("Added group: " + arraylist_employee.size() + " && with " + tmp.size() + " elements");
+                        tmp = new ArrayList<Employee>();
+                        tmp.add(tmpFreeWorker.get(i));
+                        //arraylist_employee.get(index).add(tmpFreeWorker.get(i));
+                    } else {
+                        tmp.add(tmpFreeWorker.get(i));
+                        //arraylist_employee.get(index).add(tmpFreeWorker.get(i));
+                    }
+                }
+                arraylist_employee.add(tmp);
+                System.out.println("Added last group: " + arraylist_employee.size() + " && with " + tmp.size() + " elements");
+
+            }
+
+            for (int i = 0; i < arraylist_employee.size(); i++) {
+                int position = 1;
+                b.bubbleSortTime(arraylist_employee.get(i));
+                for (int j = 0; j < arraylist_employee.get(i).size(); j++) {
+                    arraylist_employee.get(i).get(j).setPosition(position);
+                    position++;
+                }
+            }
         }
     }