Extract service logic from controllers

src/main/java/edu/byu/cs/autograder/GradingObserverImpl.java

@@ -0,0 +1,92 @@
+package edu.byu.cs.autograder;
+
+import edu.byu.cs.controller.TrafficController;
+import edu.byu.cs.dataAccess.DaoService;
+import edu.byu.cs.dataAccess.DataAccessException;
+import edu.byu.cs.model.Submission;
+import edu.byu.cs.util.Serializer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class GradingObserverImpl implements GradingObserver {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(GradingObserverImpl.class);
+
+    private final String netId;
+
+    public GradingObserverImpl(String netId) {
+        this.netId = netId;
+    }
+
+    @Override
+    public void notifyStarted() {
+        try {
+            DaoService.getQueueDao().markStarted(netId);
+        } catch (DataAccessException e) {
+            LOGGER.error("Error marking queue item as started", e);
+            return;
+        }
+
+        notifySubscribers(Map.of("type", "started"));
+
+        try {
+            TrafficController.broadcastQueueStatus();
+        } catch (Exception e) {
+            LOGGER.error("Error broadcasting queue status", e);
+        }
+    }
+
+    @Override
+    public void update(String message) {
+        notifySubscribers(Map.of("type", "update", "message", message));
+    }
+
+    @Override
+    public void notifyError(String message) {
+        notifyError(message, Map.of());
+    }
+
+    @Override
+    public void notifyError(String message, Submission submission) {
+        notifyError(message, Map.of("results", Serializer.serialize(submission)));
+    }
+
+    private void notifyError(String message, Map<String, Object> contents) {
+        contents = new HashMap<>(contents);
+        contents.put("type", "error");
+        contents.put("message", message);
+        notifySubscribers(contents);
+        removeFromQueue();
+    }
+
+    @Override
+    public void notifyWarning(String message) {
+        notifySubscribers(Map.of("type", "warning", "message", message));
+    }
+
+    @Override
+    public void notifyDone(Submission submission) {
+        notifySubscribers(Map.of("type", "results", "results", Serializer.serialize(submission)));
+        removeFromQueue();
+    }
+
+    private void notifySubscribers(Map<String, Object> contents) {
+        try {
+            TrafficController.getInstance().notifySubscribers(netId, contents);
+        } catch (Exception e) {
+            LOGGER.error("Error updating subscribers", e);
+        }
+    }
+
+    private void removeFromQueue() {
+        TrafficController.sessions.remove(netId);
+        try {
+            DaoService.getQueueDao().remove(netId);
+        } catch (DataAccessException e) {
+            LOGGER.error("Error removing queue item", e);
+        }
+    }
+}

src/main/java/edu/byu/cs/controller/AdminController.java

@@ -1,21 +1,16 @@
 package edu.byu.cs.controller;
 
-import edu.byu.cs.analytics.CommitAnalyticsRouter;
 import edu.byu.cs.canvas.CanvasException;
-import edu.byu.cs.canvas.CanvasService;
 import edu.byu.cs.canvas.model.CanvasSection;
-import edu.byu.cs.dataAccess.DaoService;
 import edu.byu.cs.dataAccess.DataAccessException;
-import edu.byu.cs.dataAccess.UserDao;
-import edu.byu.cs.honorChecker.HonorCheckerCompiler;
+import edu.byu.cs.dataAccess.ItemNotFoundException;
 import edu.byu.cs.model.User;
+import edu.byu.cs.service.AdminService;
 import edu.byu.cs.util.Serializer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import spark.Route;
 
-import java.io.File;
-import java.io.FileInputStream;
 import java.io.OutputStream;
 import java.util.Collection;
 
@@ -27,13 +22,10 @@ public class AdminController {
     private static final Logger LOGGER = LoggerFactory.getLogger(AdminController.class);
 
     public static final Route usersGet = (req, res) -> {
-        UserDao userDao = DaoService.getUserDao();
-
         Collection<User> users;
         try {
-            users = userDao.getUsers();
+            users = AdminService.getUsers();
         } catch (DataAccessException e) {
-            LOGGER.error("Error getting users", e);
             halt(500);
             return null;
         }
@@ -46,50 +38,15 @@ public class AdminController {
     };
 
     public static final Route testModeGet = (req, res) -> {
-        User latestTestStudent;
-        try {
-            latestTestStudent = CanvasService.getCanvasIntegration().getTestStudent();
-        } catch (CanvasException e) {
-            LOGGER.error("Error getting test student", e);
-            halt(500);
-            return null;
-        }
-
-        UserDao userDao = DaoService.getUserDao();
-        User user;
-        try {
-            user = userDao.getUser("test");
-        } catch (DataAccessException e) {
-            LOGGER.error("Error getting user", e);
-            halt(500);
-            return null;
-        }
-
-        try {
-
-            if (user == null) {
-                user = latestTestStudent;
-                userDao.insertUser(latestTestStudent);
-            } else {
-                userDao.setRepoUrl(user.netId(), latestTestStudent.repoUrl());
-                userDao.setCanvasUserId(user.netId(), latestTestStudent.canvasUserId());
-            }
-
-        } catch (DataAccessException e) {
-            LOGGER.error("Error updating user", e);
-            halt(500);
-            return null;
-        }
-
+        User testStudent;
         try {
-            DaoService.getSubmissionDao().removeSubmissionsByNetId(user.netId(), 0);
-        } catch (DataAccessException e) {
-            LOGGER.error("Error removing submissions", e);
+            testStudent = AdminService.updateTestStudent();
+        } catch (CanvasException | DataAccessException e) {
             halt(500);
             return null;
         }
 
-        res.cookie("/", "token", generateToken(user.netId()), 14400, false, false);
+        res.cookie("/", "token", generateToken(testStudent.netId()), 14400, false, false);
 
         res.status(200);
 
@@ -101,12 +58,7 @@ public class AdminController {
         String data;
 
         try {
-            data = switch (option) {
-                case "update" -> CommitAnalyticsRouter.update();
-                case "cached" -> CommitAnalyticsRouter.cached();
-                case "when" -> CommitAnalyticsRouter.when();
-                default -> throw new IllegalStateException("Not found (invalid option: " + option + ")");
-            };
+            data = AdminService.getCommitAnalytics(option);
         } catch (Exception e) {
             LOGGER.error(e.getMessage());
             if (e instanceof IllegalStateException) res.status(404);
@@ -121,38 +73,28 @@ public class AdminController {
 
     public static final Route honorCheckerZipGet = (req, res) -> {
         String sectionStr = req.params(":section");
-        String filePath;
 
-        res.header("Content-Type", "application/zip");
-        res.header("Content-Disposition", "attachment; filename=" + "downloaded_file.zip");
+        try (OutputStream os = res.raw().getOutputStream()) {
+            AdminService.streamHonorCheckerZip(sectionStr, os);
 
-        try {
-            filePath = HonorCheckerCompiler.compileSection(Integer.parseInt(sectionStr));
-            try (FileInputStream fis = new FileInputStream(filePath);
-                 OutputStream os = res.raw().getOutputStream()) {
-
-                byte[] buffer = new byte[4096];
-                int bytesRead;
-                while ((bytesRead = fis.read(buffer)) != -1) {
-                    os.write(buffer, 0, bytesRead);
-                }
-
-                fis.close();
-                new File(filePath).delete();
-
-                res.status(200);
-                return res.raw();
-            }
         } catch (Exception e) {
             LOGGER.error("Error compiling honor checker", e);
             res.status(500);
             return e.getMessage();
         }
+
+        res.status(200);
+
+        res.header("Content-Type", "application/zip");
+        res.header("Content-Disposition", "attachment; filename=" + "downloaded_file.zip");
+
+        return res.raw();
+
     };
 
     public static Route sectionsGet = (req, res) -> {
         try {
-            CanvasSection[] sections = CanvasService.getCanvasIntegration().getAllSections();
+            CanvasSection[] sections = AdminService.getAllSections();
             res.type("application/json");
             res.status(200);
             return Serializer.serialize(sections);

src/main/java/edu/byu/cs/controller/BadRequestException.java

@@ -0,0 +1,11 @@
+package edu.byu.cs.controller;
+
+public class BadRequestException extends Exception {
+    public BadRequestException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public BadRequestException(String message) {
+        super(message);
+    }
+}