finish group service

src/main/java/mops/gruppen2/controller/GroupCreationController.java

@@ -4,7 +4,6 @@ import mops.gruppen2.domain.Account;
 import mops.gruppen2.domain.Group;
 import mops.gruppen2.domain.GroupType;
 import mops.gruppen2.domain.User;
-import mops.gruppen2.service.ControllerService;
 import mops.gruppen2.service.CsvService;
 import mops.gruppen2.service.GroupService;
 import mops.gruppen2.service.IdService;
@@ -35,13 +34,11 @@ import static mops.gruppen2.service.IdService.uuidToString;
 public class GroupCreationController {
 
     private final GroupService groupService;
-    private final ControllerService controllerService;
     private final ValidationService validationService;
     private final ProjectionService projectionService;
 
-    public GroupCreationController(GroupService groupService, ControllerService controllerService, ValidationService validationService, ProjectionService projectionService) {
+    public GroupCreationController(GroupService groupService, ValidationService validationService, ProjectionService projectionService) {
         this.groupService = groupService;
-        this.controllerService = controllerService;
         this.validationService = validationService;
         this.projectionService = projectionService;
     }

src/main/java/mops/gruppen2/controller/GroupDetailsController.java

@@ -80,7 +80,7 @@ public class GroupDetailsController {
         model.addAttribute("private", Visibility.PRIVATE);
 
         if (validationService.checkIfAdmin(group, user)) {
-            model.addAttribute("link", serverURL + "gruppen2/acceptinvite/" + inviteService.getLinkByGroup(group.getId()));
+            model.addAttribute("link", serverURL + "gruppen2/acceptinvite/" + inviteService.getLinkByGroup(group));
         }
 
         return "detailsMember";

src/main/java/mops/gruppen2/domain/event/AddUserEvent.java

@@ -29,13 +29,6 @@ public class AddUserEvent extends Event {
         this.email = email;
     }
 
-    public AddUserEvent(UUID groupId, User user) {
-        super(groupId, user.getId());
-        givenname = user.getGivenname();
-        familyname = user.getFamilyname();
-        email = user.getEmail();
-    }
-
     public AddUserEvent(Group group, User user) {
         super(group.getId(), user.getId());
         givenname = user.getGivenname();

src/main/java/mops/gruppen2/service/GroupService.java

@@ -18,16 +18,14 @@ import mops.gruppen2.domain.event.UpdateUserLimitEvent;
 import mops.gruppen2.domain.exception.EventException;
 import org.springframework.stereotype.Service;
 
-import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.UUID;
-import java.util.stream.Collectors;
 
 /**
  * Behandelt Aufgaben, welche sich auf eine Gruppe beziehen.
  * Es werden übergebene Gruppen bearbeitet und dementsprechend Events erzeugt und gespeichert.
  */
-//TODO: Der GroupService sollte im Endeffekt größtenteils auf einer übergebenen Gruppe arbeiten.
 @Service
 @Log4j2
 public class GroupService {
@@ -63,27 +61,16 @@ public class GroupService {
                              long userLimit,
                              UUID parent) {
 
-        UUID groupId = UUID.randomUUID();
+        Group group = createGroup(user, parent, groupType, visibility, userLimit);
-        List<Event> events = new ArrayList<>();
 
-        //TODO: etwas auslagern?
+        addUser(user, group);
-        events.add(new CreateGroupEvent(groupId,
+        updateTitle(user, group, title);
-                                        user.getId(),
+        updateDescription(user, group, description);
-                                        parent,
+        updateRole(user, group, Role.ADMIN);
-                                        groupType,
-                                        visibility,
-                                        userLimit));
-        events.add(new AddUserEvent(groupId, user));
-        events.add(new UpdateGroupTitleEvent(groupId, user.getId(), title));
-        events.add(new UpdateGroupDescriptionEvent(groupId, user.getId(), description));
-        events.add(new UpdateRoleEvent(groupId, user.getId(), Role.ADMIN));
 
-        inviteService.createLink(groupId);
+        inviteService.createLink(group);
-        eventStoreService.saveAll(events);
 
-        log.trace("Es wurde eine Gruppe erstellt. ({})", visibility);
+        return group;
-
-        return ProjectionService.projectSingleGroup(events);
     }
 
 
@@ -102,12 +89,7 @@ public class GroupService {
     public void addUsersToGroup(List<User> newUsers, Group group, User user) {
         updateUserLimit(user, group, getAdjustedUserLimit(newUsers, group));
 
-        List<Event> events = newUsers.stream()
+        newUsers.forEach(newUser -> addUserSilent(newUser, group));
-                                     .filter(newUser -> !group.getMembers().contains(newUser))
-                                     .map(newUser -> new AddUserEvent(group.getId(), newUser))
-                                     .collect(Collectors.toList());
-
-        eventStoreService.saveAll(events);
     }
 
     /**
@@ -136,27 +118,58 @@ public class GroupService {
         validationService.throwIfNotInGroup(group, user);
 
         Role role = group.getRoles().get(user.getId());
-        Event updateRoleEvent = new UpdateRoleEvent(group, user, role.toggle());
+        updateRole(user, group, role.toggle());
-
-        eventStoreService.saveEvent(updateRoleEvent);
     }
 
 
     // ################################# SINGLE EVENTS ###########################################
+    // Spezifische Events werden erzeugt, validiert, auf die Gruppe angewandt und gespeichert
 
 
+    //TODO: more validation
+    private Group createGroup(User user, UUID parent, GroupType groupType, Visibility visibility, long userLimit) {
+        Event event = new CreateGroupEvent(UUID.randomUUID(),
+                                           user.getId(),
+                                           parent,
+                                           groupType, visibility,
+                                           userLimit);
+        Group group = ProjectionService.projectSingleGroup(Collections.singletonList(event));
+
+        log.trace("Es wurde eine Gruppe erstellt. ({}, {})", visibility, group.getId());
+
+        eventStoreService.saveEvent(event);
+
+        return group;
+    }
+
+    //TODO: test if exception interrupts runtime
     public void addUser(User user, Group group) {
         validationService.throwIfUserAlreadyInGroup(group, user);
 
-        AddUserEvent event = new AddUserEvent(group, user);
+        Event event = new AddUserEvent(group, user);
+        event.apply(group);
+
         eventStoreService.saveEvent(event);
     }
 
+    /**
+     * Dasselbe wie addUser(), aber exceptions werden abgefangen und nicht geworfen.
+     */
+    private void addUserSilent(User user, Group group) {
+        try {
+            addUser(user, group);
+        } catch (Exception e) {
+            log.trace("Doppelter User wurde nicht hinzugefügt ({})!", user.getId());
+        }
+    }
+
     public void deleteUser(User user, Group group) throws EventException {
         validationService.throwIfNotInGroup(group, user);
         validationService.throwIfLastAdmin(user, group);
 
-        DeleteUserEvent event = new DeleteUserEvent(group, user);
+        Event event = new DeleteUserEvent(group, user);
+        event.apply(group);
+
         eventStoreService.saveEvent(event);
 
         if (validationService.checkIfGroupEmpty(group)) {
@@ -167,27 +180,42 @@ public class GroupService {
     public void deleteGroup(User user, Group group) {
         inviteService.destroyLink(group);
 
-        DeleteGroupEvent event = new DeleteGroupEvent(group, user);
+        log.trace("Eine Gruppe wurde gelöscht ({})", group.getId());
-        eventStoreService.saveEvent(event);
 
-        log.trace("Eine Gruppe wurde gelöscht ({})", group);
+        Event event = new DeleteGroupEvent(group, user);
+        event.apply(group);
+
+        eventStoreService.saveEvent(event);
     }
 
     //TODO: Validate title
     public void updateTitle(User user, Group group, String title) {
-        UpdateGroupTitleEvent event = new UpdateGroupTitleEvent(group, user, title);
+        Event event = new UpdateGroupTitleEvent(group, user, title);
+        event.apply(group);
+
         eventStoreService.saveEvent(event);
     }
 
     //TODO: Validate description
     public void updateDescription(User user, Group group, String description) {
-        UpdateGroupDescriptionEvent event = new UpdateGroupDescriptionEvent(group, user, description);
+        Event event = new UpdateGroupDescriptionEvent(group, user, description);
+        event.apply(group);
+
+        eventStoreService.saveEvent(event);
+    }
+
+    public void updateRole(User user, Group group, Role role) {
+        Event event = new UpdateRoleEvent(group, user, role);
+        event.apply(group);
+
         eventStoreService.saveEvent(event);
     }
 
     //TODO: Validate limit
     public void updateUserLimit(User user, Group group, long userLimit) {
-        UpdateUserLimitEvent event = new UpdateUserLimitEvent(group, user, userLimit);
+        Event event = new UpdateUserLimitEvent(group, user, userLimit);
+        event.apply(group);
+
         eventStoreService.saveEvent(event);
     }
 }

src/main/java/mops/gruppen2/service/InviteService.java

@@ -20,18 +20,18 @@ public class InviteService {
         this.inviteRepository = inviteRepository;
     }
 
-    void createLink(UUID groupId) {
+    void createLink(Group group) {
         inviteRepository.save(new InviteLinkDTO(null,
-                                                groupId.toString(),
+                                                group.getId().toString(),
                                                 UUID.randomUUID().toString()));
-    }
 
-    void destroyLink(UUID groupId) {
+        log.trace("Link wurde erzeugt! (Gruppe: {})", group.getId());
-        inviteRepository.deleteLinkOfGroup(groupId.toString());
     }
 
     void destroyLink(Group group) {
         inviteRepository.deleteLinkOfGroup(group.getId().toString());
+
+        log.trace("Link wurde zerstört! (Gruppe: {})", group.getId());
     }
 
     public UUID getGroupIdFromLink(String link) {
@@ -44,13 +44,13 @@ public class InviteService {
         }
     }
 
-    public String getLinkByGroup(UUID groupId) {
+    public String getLinkByGroup(Group group) {
         try {
-            return inviteRepository.findLinkByGroupId(groupId.toString());
+            return inviteRepository.findLinkByGroupId(group.getId().toString());
         } catch (Exception e) {
-            log.error("Link zu Gruppe ({}) konnte nicht gefunden werden!", groupId);
+            log.error("Link zu Gruppe ({}) konnte nicht gefunden werden!", group.getId());
             e.printStackTrace();
-            throw new NoInviteExistException(groupId.toString());
+            throw new NoInviteExistException(group.getId().toString());
         }
     }
 }

src/main/java/mops/gruppen2/service/ValidationService.java

@@ -99,8 +99,11 @@ public class ValidationService {
         return false;
     }
 
+    /**
+     * Schmeißt keine Exception, wenn der User der letzte User ist.
+     */
     void throwIfLastAdmin(User user, Group group) {
-        if (checkIfLastAdmin(user, group)) {
+        if (!checkIfLastMember(user, group) && checkIfLastAdmin(user, group)) {
             throw new NoAdminAfterActionException("Du bist letzter Admin!");
         }
     }
@@ -114,6 +117,10 @@ public class ValidationService {
         return true;
     }
 
+    boolean checkIfLastMember(User user, Group group) {
+        return group.getMembers().contains(user) && group.getMembers().size() == 1;
+    }
+
     /**
      * Überprüft, ob alle Felder richtig gesetzt sind.
      *