Mesheiks apartment-maintenance-request-tracker

src/main/java/mesheikbrown/Layout.puml

@@ -0,0 +1,70 @@
+
+@startuml
+title Apartment Maintenance Request Tracker - Class Diagram
+
+'========================
+' MaintenanceRequest
+'========================
+class MaintenanceRequest {
+  -tenantName: String
+  -apartmentNumber: String
+  -issueType: String
+  -severity: int
+  -status: String
+  -assignedTech: String
+
+  +MaintenanceRequest()
+  +MaintenanceRequest(tenantName: String, apartmentNumber: String, issueType: String, severity: int)
+
+  +getTenantName(): String
+  +setTenantName(tenantName: String): void
+
+  +getApartmentNumber(): String
+  +setApartmentNumber(apartmentNumber: String): void
+
+  +getIssueType(): String
+  +setIssueType(issueType: String): void
+
+  +getSeverity(): int
+  +setSeverity(severity: int): void
+
+  +getStatus(): String
+  +setStatus(status: String): boolean
+
+  +getAssignedTech(): String
+  +setAssignedTech(assignedTech: String): void
+
+  +toString(): String
+}
+
+'========================
+' MaintenanceOffice
+'========================
+class MaintenanceOffice {
+  -requests: List<MaintenanceRequest>
+
+  +MaintenanceOffice()
+
+  +logRequest(request: MaintenanceRequest): void
+  +assignTech(request: MaintenanceRequest): void
+  +updateStatus(request: MaintenanceRequest, newStatus: String): boolean
+  +closeRequest(request: MaintenanceRequest): boolean
+
+  +printDailyReport(): void
+  -getMostCommonIssueType(): String
+}
+
+'========================
+' Main
+'========================
+class Main {
+  +main(args: String[]): void
+}
+
+'========================
+' Relationships
+'========================
+MaintenanceOffice "1" o-- "*" MaintenanceRequest : stores
+Main --> MaintenanceOffice : uses
+
+@enduml

src/main/java/mesheikbrown/Main.java

@@ -0,0 +1,111 @@
+package mesheikbrown;
+
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class Main {
+
+    public static void main(String[] args) {
+
+        Scanner scan = new Scanner(System.in);
+        MaintenanceOffice office = new MaintenanceOffice();
+
+        // LEVEL 1 — Create 3 requests and print with loop
+        MaintenanceRequest r1 = new MaintenanceRequest("Jordan", "3B", "Plumbing", 3);
+        MaintenanceRequest r2 = new MaintenanceRequest("Coreye", "5A", "Electrical", 5);
+        MaintenanceRequest r3 = new MaintenanceRequest("Mesheik", "2C", "Heating", 4);
+
+        // Instead of storing requests directly in Main,
+        // we send them to the MaintenanceOffice.
+        // This keeps business logic OUT of Main.
+        office.logRequest(r1);
+        office.logRequest(r2);
+        office.logRequest(r3);
+
+        System.out.println("\n--- LEVEL 1: REQUESTS ---");
+        // We loop through ALL stored requests using a for-each loop.
+        // This demonstrates loop usage.
+        for (MaintenanceRequest r : office.getRequests()) {
+
+            System.out.println(r);
+
+            // If severity is 4 or 5, mark as HIGH PRIORITY
+            if (r.getSeverity() >= 4) {
+                System.out.println("HIGH PRIORITY");
+            }
+        }
+
+        // LEVEL 2 — User intake loop (stop when "done")
+        System.out.println("\n--- LEVEL 2: ENTER REQUESTS ---");
+
+        // This loop continues until user types "done"
+        while (true) {
+
+            System.out.print("Tenant name (or type 'done'): ");
+            String tenantName = scan.nextLine();
+
+            // If user types "done", stop the loop
+            if (tenantName.equalsIgnoreCase("done")) {
+                break;
+            }
+
+            System.out.print("Apartment number: ");
+            String apt = scan.nextLine();
+
+            System.out.print("Issue type: ");
+            String issueType = scan.nextLine();
+
+            System.out.print("Severity (1-5): ");
+            int severity = Integer.parseInt(scan.nextLine());
+
+            MaintenanceRequest newReq = new MaintenanceRequest(tenantName,apt, issueType, severity);
+
+            // LEVEL 2 RULES
+            // If issue is Electrical AND severity >= 4
+            // Print warning message
+            if (issueType.equalsIgnoreCase("Electrical") && severity >= 4) {
+                System.out.println(" WARNING: High severity ELECTRICAL issue!");
+            }
+            // If severity is 5 → dispatch immediately
+            if (severity == 5) {
+                System.out.println(" DISPATCH IMMEDIATELY: Severity 5 request!");
+            }
+
+            // Send request to MaintenanceOffice to store and assign tech
+            office.logRequest(newReq);
+            System.out.println("Request logged: " + newReq);
+            System.out.println();
+        }
+
+        // We grab all stored requests from the office.
+        ArrayList<MaintenanceRequest> all = office.getRequests();
+
+        // If at least one request exists,
+        // demonstrate updating and closing.
+        if (all.size() > 0) {
+            MaintenanceRequest first = all.get(0);
+
+            System.out.println("\n--- LEVEL 3: STATUS UPDATE DEMO ---");
+            System.out.println("Before: " + first);
+
+            // Update status to IN_PROGRESS
+            office.updateStatus(first, "IN_PROGRESS");
+
+            // Update status to DONE
+            office.updateStatus(first, "DONE");
+
+            // Attempt to close (only works if status is DONE)
+            office.closeRequest(first);
+
+            System.out.println("After:  " + first);
+        }
+
+        // LEVEL 4 — Daily report
+        // Generate full system report
+        // This demonstrates loops + conditionals inside the office class.
+        office.printDailyReport();
+
+        // Close scanner to prevent memory leak warning
+        scan.close();
+    }
+}

src/main/java/mesheikbrown/MaintenanceOffice.java

@@ -0,0 +1,165 @@
+package mesheikbrown;
+
+import java.util.ArrayList;
+
+public class MaintenanceOffice {
+
+    // Store all maintenance requests here
+    private ArrayList<MaintenanceRequest> requests;
+
+    // Constructor
+    public MaintenanceOffice() {
+        requests = new ArrayList<>();
+    }
+
+
+    // LEVEL 3
+    // Add request and assign tech automatically
+    public void logRequest(MaintenanceRequest request) {
+        assignTech(request);
+        requests.add(request);
+        System.out.println("Request logged successfully.");
+    }
+
+    // Assign tech based on severity
+    public void assignTech(MaintenanceRequest request) {
+
+        int severity = request.getSeverity();
+
+        if (severity <= 2) {
+            request.setAssignedTech("General Maintenance");
+        }
+        else if (severity <= 4) {
+            request.setAssignedTech("Senior Technician");
+        }
+        else { // severity == 5
+            request.setAssignedTech("Emergency On-Call");
+        }
+    }
+
+    // Update status (ONLY allow valid statuses)
+    public void updateStatus(MaintenanceRequest request, String newStatus) {
+
+        newStatus = newStatus.toUpperCase();
+
+        if (newStatus.equals("NEW") ||
+                newStatus.equals("IN_PROGRESS") ||
+                newStatus.equals("DONE")) {
+
+            request.setStatus(newStatus);
+            System.out.println("Status updated.");
+        }
+        else {
+            System.out.println("Invalid status. Must be NEW, IN_PROGRESS, or DONE.");
+        }
+    }
+
+
+
+
+    // Close request only if DONE
+    public void closeRequest(MaintenanceRequest request) {
+
+        if (request.getStatus().equals("DONE")) {
+            System.out.println("Request is officially CLOSED.");
+        } else {
+            System.out.println("Cannot close request unless status is DONE.");
+        }
+    }
+
+    // Print all requests
+    public void printAllRequests() {
+        for (MaintenanceRequest request : requests) {
+            System.out.println(request);
+
+            if (request.getSeverity() >= 4) {
+                System.out.println("HIGH PRIORITY");
+            }
+        }
+    }
+
+    // LEVEL 4 – DAILY REPORT
+    public void printDailyReport() {
+
+        int total = requests.size();
+        int open = 0;
+        int closed = 0;
+
+        int low = 0;
+        int medium = 0;
+        int high = 0;
+
+        int highPriorityOpen = 0;
+
+        // For most common issue
+        String mostCommonIssue = "";
+        int highestCount = 0;
+
+        for (int i = 0; i < requests.size(); i++) {
+
+            MaintenanceRequest current = requests.get(i);
+
+            // Open vs Closed
+            if (current.getStatus().equals("DONE")) {
+                closed++;
+            } else {
+                open++;
+            }
+
+            // Severity categories
+            int sev = current.getSeverity();
+
+            if (sev <= 2) {
+                low++;
+            }
+            else if (sev == 3) {
+                medium++;
+            }
+            else {
+                high++;
+            }
+
+            if (sev >= 4 && !current.getStatus().equals("DONE")) {
+                highPriorityOpen++;
+            }
+
+            // Count how many times this issue appears
+            int count = 0;
+
+            for (int j = 0; j < requests.size(); j++) {
+                if (requests.get(j).getIssueType()
+                        .equalsIgnoreCase(current.getIssueType())) {
+                    count++;
+                }
+            }
+
+            if (count > highestCount) {
+                highestCount = count;
+                mostCommonIssue = current.getIssueType();
+            }
+        }
+
+        // Print Report
+        System.out.println("\n===== DAILY REPORT =====");
+        System.out.println("Total Requests: " + total);
+        System.out.println("Open Requests: " + open);
+        System.out.println("Closed Requests: " + closed);
+
+        System.out.println("\nSeverity Breakdown:");
+        System.out.println("Low (1-2): " + low);
+        System.out.println("Medium (3): " + medium);
+        System.out.println("High (4-5): " + high);
+
+        System.out.println("\nMost Common Issue: " + mostCommonIssue);
+
+        if (highPriorityOpen > 3) {
+            System.out.println(" OVERLOAD WARNING: Too many high priority open requests!");
+        }
+
+        System.out.println("========================\n");
+    }
+
+    public ArrayList<MaintenanceRequest> getRequests() {
+        return requests;
+    }
+}