Verbeter error handling in de EventController

src/main/java/puzzeltocht/controller/EventController.java

@@ -6,7 +6,9 @@ import puzzeltocht.controller.dto.EventDto;
 import puzzeltocht.controller.dto.MissionDto;
 import puzzeltocht.controller.dto.TeamCreateDto;
 import puzzeltocht.controller.dto.TeamUpdateDto;
+import puzzeltocht.domain.Event;
 import puzzeltocht.domain.Mission;
+import puzzeltocht.domain.Team;
 import puzzeltocht.service.EventService;
 
 import java.util.List;
@@ -31,14 +33,25 @@ public class EventController {
 
     @RequestMapping(method = RequestMethod.GET, path ="event/{id}")
     public ResponseEntity<EventDto> event(@PathVariable UUID id) {
-        EventDto e = new EventDto(eventService.get(id));
-        return ResponseEntity.ok(e);
+        Event e = eventService.get(id);
+
+        if (e == null) {
+            return ResponseEntity.notFound().build();
+        }
+
+        return ResponseEntity.ok(new EventDto(e));
     }
 
     @RequestMapping(method = RequestMethod.POST, path ="event/{eventId}/team")
     public ResponseEntity<UUID> teamCreate(@PathVariable UUID eventId, @RequestBody TeamCreateDto team) {
-        UUID teamId = eventService.createTeam(eventId, team);
-        return ResponseEntity.ok(teamId);
+        Event e = eventService.get(eventId);
+
+        if (e == null) {
+            return ResponseEntity.notFound().build();
+        }
+
+        Team t = eventService.createTeam(e, team);
+        return ResponseEntity.ok(t.getId());
     }
 
     @RequestMapping(method = RequestMethod.PUT, path ="event/{eventId}/team/{teamId}")
@@ -46,7 +59,13 @@ public class EventController {
             @PathVariable UUID eventId,
             @PathVariable UUID teamId,
             @RequestBody TeamUpdateDto update) {
-        Mission m = eventService.updateMission(eventId, teamId, update);
+        Event e = eventService.get(eventId);
+        Team t = e == null ? null : e.getTeam(teamId);
+        if (e == null || t == null) {
+            return ResponseEntity.notFound().build();
+        }
+
+        Mission m = eventService.updateMission(e, t, update);
         MissionDto dto = new MissionDto(m, update.getLocation());
         return ResponseEntity.ok(dto);
     }

src/main/java/puzzeltocht/domain/Event.java

@@ -1,16 +1,13 @@
 package puzzeltocht.domain;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.UUID;
+import java.util.*;
 
 public class Event {
     private final UUID id;
     private final String title;
     private final String description;
     private final Route route;
-    private final List<Team> teams = new ArrayList<>();
+    private final Map<UUID, Team> teams = new HashMap<>();
 
     public Event(String title, String description, Route r) {
         this.id = UUID.randomUUID();
@@ -32,11 +29,15 @@ public class Event {
     }
 
     public void addTeam(Team t) {
-        teams.add(t);
+        teams.put(t.getId(), t);
     }
 
-    public List<Team> getTeams() {
-        return Collections.unmodifiableList(teams);
+    public Collection<Team> getTeams() {
+        return Collections.unmodifiableCollection(teams.values());
+    }
+
+    public Team getTeam(UUID id) {
+        return teams.get(id);
     }
 
     public Mission nextMission(Mission m) {

src/main/java/puzzeltocht/service/EventService.java

@@ -5,44 +5,39 @@ import puzzeltocht.controller.dto.TeamCreateDto;
 import puzzeltocht.controller.dto.TeamUpdateDto;
 import puzzeltocht.domain.*;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.UUID;
+import java.util.*;
 
 @Service
 public class EventService {
 
-    private final RouteService routeService;
     private final TeamService teamService;
 
-    private final List<Event> events = new ArrayList<>();
+    private final Map<UUID, Event> events = new HashMap<>();
 
     public EventService(RouteService rs, TeamService ts) {
-        this.routeService = rs;
         this.teamService = ts;
-        this.events.add(demoEvent());
+        createEvent("Summercamp MINI puzzeltocht", "Korte route", rs.mockRoute());
+        createEvent("Summercamp MAXI puzzeltocht", "Lange route", rs.mockRoute());
     }
 
-    public List<Event> currentEvents() {
-        return events;
+    private void createEvent(String title, String description, Route r){
+        Event e = new Event(title, description, r);
+        events.put(e.getId(), e);
     }
 
-    public Event get(UUID id) {
-        return events.stream()
-                .filter(r -> r.getId().equals(id))
-                .findFirst().orElseThrow(IllegalStateException::new);
+    public Collection<Event> currentEvents() {
+        return events.values();
     }
 
-    private Event demoEvent() {
-        Route r = routeService.mockRoute();
-        return new Event("Summercamp puzzeltocht", "", r);
+    public Event get(UUID id) {
+        return events.get(id);
     }
 
-    public Mission updateMission(UUID eventId, UUID teamId, TeamUpdateDto update) {
-        return teamService.updateMission(get(eventId), teamId, update);
+    public Mission updateMission(Event e, Team t, TeamUpdateDto update) {
+        return teamService.updateMission(e, t, update);
     }
 
-    public UUID createTeam(UUID eventId, TeamCreateDto team) {
-        return teamService.create(get(eventId), team);
+    public Team createTeam(Event e, TeamCreateDto team) {
+        return teamService.create(e, team);
     }
 }

src/main/java/puzzeltocht/service/TeamService.java

@@ -7,8 +7,6 @@ import puzzeltocht.domain.Event;
 import puzzeltocht.domain.Mission;
 import puzzeltocht.domain.Team;
 
-import java.util.UUID;
-
 @Service
 public class TeamService {
     private final MissionService missionService;
@@ -17,15 +15,14 @@ public class TeamService {
         this.missionService = ms;
     }
 
-    public UUID create(Event event, TeamCreateDto team) {
+    public Team create(Event event, TeamCreateDto team) {
         Team t = new Team(team.getName());
         event.addTeam(t);
-        updateMission(event, t.getId(), null);
-        return t.getId();
+        updateMission(event, t, null);
+        return t;
     }
 
-    public Mission updateMission(Event event, UUID teamId, TeamUpdateDto update) {
-        Team t = find(event, teamId);
+    public Mission updateMission(Event event, Team t, TeamUpdateDto update) {
         Mission m = t.getCurrentMission();
 
         if (m == null || missionService.evaluate(m, update)) {
@@ -36,9 +33,4 @@ public class TeamService {
         return t.getCurrentMission();
     }
 
-    private Team find(Event event, UUID teamId) {
-        return event.getTeams().stream()
-                .filter(t -> t.getId().equals(teamId))
-                .findFirst().orElseThrow(IllegalArgumentException::new);
-    }
 }