Merge remote-tracking branch 'origin/performance-tests' into groups-for-user

# Conflicts:
#	src/main/java/mops/gruppen2/service/GroupService.java

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

@@ -1,13 +1,12 @@
 package mops.gruppen2.service;
 
-import mops.gruppen2.domain.EventDTO;
+import lombok.EqualsAndHashCode;
 import mops.gruppen2.domain.Exceptions.EventException;
 import mops.gruppen2.domain.Exceptions.GroupDoesNotExistException;
 import mops.gruppen2.domain.Group;
 import mops.gruppen2.domain.event.CreateGroupEvent;
 import mops.gruppen2.domain.event.DeleteGroupEvent;
 import mops.gruppen2.domain.event.Event;
-import mops.gruppen2.repository.EventRepository;
 import org.springframework.stereotype.Service;
 
 import java.util.ArrayList;
@@ -19,52 +18,28 @@ import java.util.Map;
 public class GroupService {
 
     private final EventService eventService;
-    private final EventRepository eventRepository;
 
-    public GroupService(EventService eventService, EventRepository eventRepository) {
+    public GroupService(EventService eventService) {
         this.eventService = eventService;
-        this.eventRepository = eventRepository;
     }
 
-    public List<Event> getGroupEvents(List<Long> group_ids) {
-        List<EventDTO> eventDTOS = new ArrayList<>();
-        List<Event> events = new ArrayList<>();
-        for (Long group_id: group_ids) {
-            eventDTOS.addAll(eventRepository.findEventDTOByGroup_id(group_id));
-        }
-        return events = eventService.translateEventDTOs(eventDTOS);
-    }
 
-    public List<Group> projectEventList(Map<Long, Group> groupMap, List<Event> events) throws EventException {
+    public List<Group> projectEventList(List<Event> events) throws EventException {
+        Map<Long, Group> groupMap = new HashMap<>();
+
         for (Event event : events) {
-            if (event instanceof CreateGroupEvent) {
+            getOrCreateGroup(groupMap, event.getGroup_id()).applyEvent(event);
-                groupMap.put(event.getGroup_id(), new Group());
-            }
-            if (event instanceof DeleteGroupEvent) {
-                groupMap.remove(event.getGroup_id());
-            } else {
-                try {
-                    Group group = groupMap.get(event.getGroup_id());
-
-                    if (group == null) {
-                        throw new GroupDoesNotExistException("Gruppe " + event.getGroup_id() + " existiert nicht");
-                    }
-
-                    group.applyEvent(event);
-                } catch (EventException e) {
-                    if (e instanceof GroupDoesNotExistException) {
-                        throw e;
-                    }
-                    e.printStackTrace();
-                }
-            }
-
         }
 
         return new ArrayList<>(groupMap.values());
     }
 
-    public List<Group> projectEventList(List<Event> events) throws EventException {
+    //
-        return projectEventList(new HashMap<>(), events);
+    private Group getOrCreateGroup(Map<Long, Group> groups, long group_id) {
+        if (!groups.containsKey(group_id)) {
+            groups.put(group_id, new Group());
+        }
+
+        return groups.get(group_id);
     }
 }

src/test/java/mops/gruppen2/builder/EventBuilder.java

@@ -1,7 +1,7 @@
 package mops.gruppen2.builder;
 
 import com.github.javafaker.Faker;
-import mops.gruppen2.domain.Role;
+import mops.gruppen2.domain.*;
 import mops.gruppen2.domain.event.*;
 
 import java.util.ArrayList;
@@ -9,19 +9,64 @@ import java.util.List;
 
 public class EventBuilder {
 
-    public static CreateGroupEvent randomCreateGroupEvent() {
+    /**
-        Faker faker = new Faker();
+     * Generiert ein EventLog mit mehreren Gruppen nud Usern
+     *
+     * @param count Gruppenanzahl
+     * @param membercount Gesamte Mitgliederanzahl
+     * @return
+     */
+    public static List<Event> completeGroups(int count, int membercount) {
+        List<Event> eventList = new ArrayList<>();
 
-        return null;/*new CreateGroupEvent(
+        for (int i = 1; i <= count; i++) {
-                faker.random().nextLong(),
+            eventList.addAll(EventBuilder.completeGroup(i, membercount / count));
-                faker.random().nextLong(),
-                faker.random().hex(),
-                faker.leagueOfLegends().champion(),
-                faker.leagueOfLegends().quote()
-        );*/
         }
 
-    public static AddUserEvent randomAddUserEvent(long group_id) {
+        return eventList;
+    }
+
+    public static List<Event> completeGroup(long group_id, int membercount) {
+        List<Event> eventList = new ArrayList<>();
+
+        eventList.add(EventBuilder.createGroupEvent(group_id));
+        eventList.add(EventBuilder.updateGroupTitleEvent(group_id));
+        eventList.add(EventBuilder.updateGroupDescriptionEvent(group_id));
+
+        eventList.addAll(EventBuilder.addUserEvents(membercount, group_id));
+
+        return eventList;
+    }
+
+    public static CreateGroupEvent createGroupEvent(long group_id) {
+        Faker faker = new Faker();
+
+        return new CreateGroupEvent(
+                group_id,
+                faker.random().hex(),
+                null,
+                GroupType.SIMPLE,
+                Visibility.PRIVATE
+        );
+    }
+
+    /**
+     * Generiert mehrere CreateGroupEvents, 1 <= group_id <= count
+     *
+     * @param count Anzahl der verschiedenen Gruppen.
+     * @return
+     */
+    public static List<CreateGroupEvent> createGroupEvents(int count) {
+        List<CreateGroupEvent> eventList = new ArrayList<>();
+
+        for (int i = 1; i <= count; i++) {
+            eventList.add(createGroupEvent(i));
+        }
+
+        return eventList;
+    }
+
+    public static AddUserEvent addUserEvent(long group_id, String user_id) {
         Faker faker = new Faker();
 
         String firstname = faker.name().firstName();
@@ -30,24 +75,31 @@ public class EventBuilder {
         return new AddUserEvent(
                 faker.random().nextLong(),
                 group_id,
-                faker.random().hex(),
+                user_id,
                 firstname,
                 lastname,
                 firstname + "." + lastname + "@mail.de"
         );
     }
 
-    public static List<Event> randomAddUserEvents(int count, long group_id) {
+    /**
+     * Generiert mehrere AddUserEvents für eine Gruppe, 1 <= user_id <= count
+     *
+     * @param count
+     * @param group_id
+     * @return
+     */
+    public static List<Event> addUserEvents(int count, long group_id) {
         List<Event> eventList = new ArrayList<>();
 
-        for (int i = 0; i < count; i++) {
+        for (int i = 1; i <= count; i++) {
-            eventList.add(EventBuilder.randomAddUserEvent(group_id));
+            eventList.add(EventBuilder.addUserEvent(group_id, "" + i));
         }
 
         return eventList;
     }
 
-    public static DeleteUserEvent randomDeleteUserEvent(long group_id, String user_id) {
+    public static DeleteUserEvent deleteUserEvent(long group_id, String user_id) {
         Faker faker = new Faker();
 
         return new DeleteUserEvent(
@@ -57,7 +109,23 @@ public class EventBuilder {
         );
     }
 
-    public static UpdateGroupDescriptionEvent randomUpdateGroupDescriptionEvent(long group_id) {
+    /**
+     * Erzeugt mehrere DeleteUserEvents, sodass eine Gruppe komplett geleert wird
+     *
+     * @param group Gruppe welche geleert wird
+     * @return
+     */
+    public static List<DeleteUserEvent> deleteUserEvents(Group group) {
+        List<DeleteUserEvent> eventList = new ArrayList<>();
+
+        for (User user : group.getMembers()) {
+            eventList.add(EventBuilder.deleteUserEvent(group.getId(), user.getUser_id()));
+        }
+
+        return eventList;
+    }
+
+    public static UpdateGroupDescriptionEvent updateGroupDescriptionEvent(long group_id) {
         Faker faker = new Faker();
 
         return new UpdateGroupDescriptionEvent(
@@ -68,7 +136,7 @@ public class EventBuilder {
         );
     }
 
-    public static UpdateGroupTitleEvent randomUpdateGroupTitleEvent(long group_id) {
+    public static UpdateGroupTitleEvent updateGroupTitleEvent(long group_id) {
         Faker faker = new Faker();
 
         return new UpdateGroupTitleEvent(