[AB-132] fixing experience job not creating user experience records in the database

fixing setup command not being considered templated
changing column name for counters
fixing liquibase configuration for creating postgres functions
fixing duration format expcetion model not available in the template
enabling builds for hotfix/bugfix branches

.github/workflows/build.yml

@@ -8,6 +8,8 @@ on:
     branches:
       - master
       - feature/**
+      - hotfix/**
+      - bugfix/**
   pull_request:
     branches: [ master ]
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/job/ExperiencePersistingJob.java

@@ -1,6 +1,6 @@
 package dev.sheldan.abstracto.experience.job;
 
-import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.experience.models.ServerExperience;
 import dev.sheldan.abstracto.experience.service.AUserExperienceService;
 import lombok.extern.slf4j.Slf4j;
 import org.quartz.DisallowConcurrentExecution;
@@ -32,13 +32,14 @@ public class ExperiencePersistingJob extends QuartzJobBean {
 
     @Override
     protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
-        Map<Long, List<AServer>> runtimeExperience = userExperienceService.getRuntimeExperience();
+        Map<Long, List<ServerExperience>> runtimeExperience = userExperienceService.getRuntimeExperience();
         log.info("Running experience persisting job.");
         Long pastMinute = (Instant.now().getEpochSecond() / 60) - 1;
         if(runtimeExperience.containsKey(pastMinute)) {
             log.info("Found experience to persist.");
-            userExperienceService.handleExperienceGain(runtimeExperience.get(pastMinute));
+            userExperienceService.handleExperienceGain(runtimeExperience.get(pastMinute)).thenAccept(aVoid ->
-            runtimeExperience.remove(pastMinute);
+                runtimeExperience.remove(pastMinute)
+            );
         }
     }
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/repository/UserExperienceRepository.java

@@ -3,15 +3,18 @@ package dev.sheldan.abstracto.experience.repository;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.experience.models.database.LeaderBoardEntryResult;
 import dev.sheldan.abstracto.experience.models.database.AUserExperience;
+import org.jetbrains.annotations.NotNull;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.jpa.repository.QueryHints;
 import org.springframework.data.repository.query.Param;
+import org.springframework.lang.NonNull;
 import org.springframework.stereotype.Repository;
 
 import javax.persistence.QueryHint;
 import java.util.List;
+import java.util.Optional;
 
 /**
  * Repository to manage the access to the table managed by {@link AUserExperience}
@@ -54,4 +57,9 @@ public interface UserExperienceRepository  extends JpaRepository<AUserExperience
             "FROM user_experience_ranked rank " +
             "WHERE rank.id = :userInServerId", nativeQuery = true)
     LeaderBoardEntryResult getRankOfUserInServer(@Param("userInServerId") Long id, @Param("serverId") Long serverId);
+
+    @NotNull
+    @Override
+    @QueryHints(@QueryHint(name = org.hibernate.annotations.QueryHints.CACHEABLE, value = "true"))
+    Optional<AUserExperience> findById(@NonNull Long aLong);
 }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/AUserExperienceServiceBean.java

@@ -8,15 +8,13 @@ import dev.sheldan.abstracto.core.service.BotService;
 import dev.sheldan.abstracto.core.service.ConfigService;
 import dev.sheldan.abstracto.core.service.MessageService;
 import dev.sheldan.abstracto.core.service.RoleService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.core.utils.CompletableFutureList;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.experience.config.features.ExperienceFeatureConfig;
-import dev.sheldan.abstracto.experience.models.ExperienceGainResult;
+import dev.sheldan.abstracto.experience.models.*;
-import dev.sheldan.abstracto.experience.models.RoleCalculationResult;
 import dev.sheldan.abstracto.experience.models.database.*;
-import dev.sheldan.abstracto.experience.models.LeaderBoard;
-import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
 import dev.sheldan.abstracto.experience.models.templates.UserSyncStatusModel;
 import dev.sheldan.abstracto.experience.service.management.DisabledExpRoleManagementService;
 import dev.sheldan.abstracto.experience.service.management.ExperienceLevelManagementService;
@@ -79,6 +77,9 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
     @Autowired
     private RunTimeExperienceService runTimeExperienceService;
 
+    @Autowired
+    private ServerManagementService serverManagementService;
+
     @Autowired
     private AUserExperienceServiceBean self;
 
@@ -89,27 +90,27 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
     @Override
     public void addExperience(AUserInAServer userInAServer) {
         Long second = Instant.now().getEpochSecond() / 60;
-        Map<Long, List<AServer>> runtimeExperience = runTimeExperienceService.getRuntimeExperience();
+        Map<Long, List<ServerExperience>> runtimeExperience = runTimeExperienceService.getRuntimeExperience();
         if(runtimeExperience.containsKey(second)) {
-            List<AServer> existing = runtimeExperience.get(second);
+            List<ServerExperience> existing = runtimeExperience.get(second);
             existing.forEach(server -> {
-                if(server.getUsers().stream().noneMatch(userInAServer1 -> userInAServer.getUserInServerId().equals(userInAServer1.getUserInServerId()))) {
+                if(server.getUserInServerIds().stream().noneMatch(userInAServer1 -> userInAServer.getUserInServerId().equals(userInAServer1))) {
-                    server.getUsers().add(userInAServer);
+                    server.getUserInServerIds().add(userInAServer.getUserInServerId());
                 }
             });
 
         } else {
-            AServer server = AServer
+            ServerExperience serverExperience = ServerExperience
                     .builder()
-                    .id(userInAServer.getServerReference().getId())
+                    .serverId(userInAServer.getServerReference().getId())
                     .build();
-            server.getUsers().add(userInAServer);
+            serverExperience.getUserInServerIds().add(userInAServer.getUserInServerId());
-            runtimeExperience.put(second, Arrays.asList(server));
+            runtimeExperience.put(second, new ArrayList<>(Arrays.asList(serverExperience)));
         }
     }
 
     @Override
-    public Map<Long, List<AServer>> getRuntimeExperience() {
+    public Map<Long, List<ServerExperience>> getRuntimeExperience() {
         return runTimeExperienceService.getRuntimeExperience();
     }
 
@@ -158,47 +159,70 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
      */
     @Transactional
     @Override
-    public CompletableFuture<Void> handleExperienceGain(List<AServer> servers) {
+    public CompletableFuture<Void> handleExperienceGain(List<ServerExperience> servers) {
         List<ExperienceGainResult> resultFutures = new ArrayList<>();
         List<CompletableFuture<RoleCalculationResult>> futures = new ArrayList<>();
         List<AExperienceLevel> levels = experienceLevelManagementService.getLevelConfig();
         // TODO what if there are a lot in here...., transaction size etc
         servers.forEach(serverExp -> {
-            log.trace("Handling experience for server {}", serverExp.getId());
+            AServer server = serverManagementService.loadOrCreate(serverExp.getServerId());
-            int minExp = configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, serverExp.getId()).intValue();
+            log.trace("Handling experience for server {}", serverExp.getServerId());
-            int maxExp = configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, serverExp.getId()).intValue();
+            int minExp = configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, serverExp.getServerId()).intValue();
-            Double multiplier = configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverExp.getId());
+            int maxExp = configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, serverExp.getServerId()).intValue();
-            PrimitiveIterator.OfInt iterator = new Random().ints(serverExp.getUsers().size(), minExp, maxExp + 1).iterator();
+            Double multiplier = configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverExp.getServerId());
+            PrimitiveIterator.OfInt iterator = new Random().ints(serverExp.getUserInServerIds().size(), minExp, maxExp + 1).iterator();
             levels.sort(Comparator.comparing(AExperienceLevel::getExperienceNeeded));
-            List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(serverExp);
+            List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);
-            List<ADisabledExpRole> disabledExpRoles = disabledExpRoleManagementService.getDisabledRolesForServer(serverExp);
+            List<ADisabledExpRole> disabledExpRoles = disabledExpRoleManagementService.getDisabledRolesForServer(server);
             List<ARole> disabledRoles = disabledExpRoles.stream().map(ADisabledExpRole::getRole).collect(Collectors.toList());
             roles.sort(Comparator.comparing(role -> role.getLevel().getLevel()));
-            serverExp.getUsers().forEach(userInAServer -> {
+            serverExp.getUserInServerIds().forEach(userInAServerId -> {
                 Integer gainedExperience = iterator.next();
+                AUserInAServer userInAServer = userInServerManagementService.loadUser(userInAServerId);
                 gainedExperience = (int) Math.floor(gainedExperience * multiplier);
                 Member member = botService.getMemberInServer(userInAServer);
                 if(!roleService.hasAnyOfTheRoles(member, disabledRoles)) {
                     log.trace("Handling {}. The user gains {}", userInAServer.getUserReference().getId(), gainedExperience);
-                    AUserExperience aUserExperience = userExperienceManagementService.findUserInServer(userInAServer);
+                    Optional<AUserExperience> aUserExperienceOptional = userExperienceManagementService.findByUserInServerIdOptional(userInAServerId);
-                    if(Boolean.FALSE.equals(aUserExperience.getExperienceGainDisabled())) {
+                    if(aUserExperienceOptional.isPresent()) {
-                        Long newExperienceCount = aUserExperience.getExperience() + gainedExperience.longValue();
+                        AUserExperience aUserExperience = aUserExperienceOptional.get();
-                        AExperienceLevel newLevel = calculateLevel(levels, newExperienceCount);
+                        if(Boolean.FALSE.equals(aUserExperience.getExperienceGainDisabled())) {
-                        CompletableFuture<RoleCalculationResult> resultFuture = updateUserRole(aUserExperience, roles, newLevel.getLevel());
+                            Long newExperienceCount = aUserExperience.getExperience() + gainedExperience.longValue();
-                        Long newMessageCount = aUserExperience.getMessageCount() + 1L;
+                            AExperienceLevel newLevel = calculateLevel(levels, newExperienceCount);
+                            CompletableFuture<RoleCalculationResult> resultFuture = updateUserRole(aUserExperience, roles, newLevel.getLevel());
+                            Long newMessageCount = aUserExperience.getMessageCount() + 1L;
+                            ExperienceGainResult calculationResult =
+                                    ExperienceGainResult
+                                            .builder()
+                                            .calculationResult(resultFuture)
+                                            .newExperience(newExperienceCount)
+                                            .newMessageCount(newMessageCount)
+                                            .newLevel(newLevel.getLevel())
+                                            .userInServerId(userInAServer.getUserInServerId())
+                                            .build();
+                            resultFutures.add(calculationResult);
+                            futures.add(resultFuture);
+                        } else {
+                            log.trace("Experience gain was disabled. User did not gain any experience.");
+                        }
+                    } else {
+                        log.info("user experience for user {} was not found. Planning to create new instance.", userInAServer.getUserInServerId());
+                        Long newExperience = gainedExperience.longValue();
+                        AExperienceLevel newLevel = calculateLevel(levels, newExperience);
+                        Long newMessageCount = 1L;
+                        CompletableFuture<RoleCalculationResult> resultFuture = applyInitialRole(userInAServer, roles, newLevel.getLevel());
                         ExperienceGainResult calculationResult =
                                 ExperienceGainResult
-                                    .builder()
+                                        .builder()
                                         .calculationResult(resultFuture)
-                                        .newExperience(newExperienceCount)
+                                        .newExperience(newExperience)
                                         .newMessageCount(newMessageCount)
                                         .newLevel(newLevel.getLevel())
+                                        .createUserExperience(true)
                                         .userInServerId(userInAServer.getUserInServerId())
-                                    .build();
+                                        .build();
                         resultFutures.add(calculationResult);
                         futures.add(resultFuture);
-                    } else {
-                        log.trace("Experience gain was disabled. User did not gain any experience.");
                     }
                 } else {
                     log.trace("User {} has a role which makes the user unable to gain experience.", userInAServer.getUserInServerId());
@@ -211,13 +235,45 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
         );
     }
 
+    private CompletableFuture<RoleCalculationResult> applyInitialRole(AUserInAServer aUserInAServer, List<AExperienceRole> roles, Integer currentLevel) {
+        if(!botService.isUserInGuild(aUserInAServer)) {
+            log.trace("User {} is not in server {} anymore. No role calculation done.", aUserInAServer.getUserInServerId(), aUserInAServer.getServerReference().getId());
+            return CompletableFuture.completedFuture(RoleCalculationResult
+                    .builder()
+                    .userInServerId(aUserInAServer.getUserInServerId())
+                    .experienceRoleId(null)
+                    .build());
+        }
+        AExperienceRole role = experienceRoleService.calculateRole(roles, currentLevel);
+        if(role == null) {
+            return CompletableFuture.completedFuture(RoleCalculationResult
+                    .builder()
+                    .userInServerId(aUserInAServer.getUserInServerId())
+                    .experienceRoleId(null)
+                    .build());
+        }
+        Long experienceRoleId = role.getId();
+        Long userInServerId = aUserInAServer.getUserInServerId();
+        return roleService.addRoleToUserFuture(aUserInAServer, role.getRole()).thenApply(aVoid -> RoleCalculationResult
+                .builder()
+                .experienceRoleId(experienceRoleId)
+                .userInServerId(userInServerId)
+                .build());
+    }
+
     @Transactional
     public void persistExperienceChanges(List<ExperienceGainResult> resultFutures) {
         List<AExperienceLevel> levels = experienceLevelManagementService.getLevelConfig();
         HashMap<Long, List<AExperienceRole>> serverRoleMapping = new HashMap<>();
         resultFutures.forEach(experienceGainResult -> {
             AUserInAServer user = userInServerManagementService.loadUser(experienceGainResult.getUserInServerId());
-            AUserExperience userExperience = userExperienceManagementService.findUserInServer(user);
+            AUserExperience userExperience;
+            if(experienceGainResult.isCreateUserExperience()) {
+                userExperience = userExperienceManagementService.createUserInServer(user);
+                log.info("Creating new experience user {}", experienceGainResult.getUserInServerId());
+            } else {
+                userExperience = userExperienceManagementService.findByUserInServerId(experienceGainResult.getUserInServerId());
+            }
             userExperience.setMessageCount(experienceGainResult.getNewMessageCount());
             userExperience.setExperience(experienceGainResult.getNewExperience());
             Optional<AExperienceLevel> foundLevel = levels.stream().filter(level -> level.getLevel().equals(experienceGainResult.getNewLevel())).findFirst();
@@ -233,6 +289,9 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
             List<AExperienceRole> roleConfig = serverRoleMapping.get(server.getId());
             AExperienceRole role = experienceRoleService.calculateRole(roleConfig, userExperience.getLevelOrDefault());
             userExperience.setCurrentExperienceRole(role);
+            if(experienceGainResult.isCreateUserExperience()) {
+                userExperienceManagementService.saveUser(userExperience);
+            }
         });
     }
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/RunTimeExperienceService.java

@@ -1,6 +1,6 @@
 package dev.sheldan.abstracto.experience.service;
 
-import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.experience.models.ServerExperience;
 import org.springframework.stereotype.Component;
 
 import java.util.HashMap;
@@ -9,9 +9,9 @@ import java.util.Map;
 
 @Component
 public class RunTimeExperienceService {
-    private Map<Long, List<AServer>> runtimeExperience = new HashMap<>();
+    private Map<Long, List<ServerExperience>> runtimeExperience = new HashMap<>();
 
-    public Map<Long, List<AServer>> getRuntimeExperience() {
+    public Map<Long, List<ServerExperience>> getRuntimeExperience() {
         return runtimeExperience;
     }
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/management/UserExperienceManagementServiceBean.java

@@ -1,6 +1,7 @@
 package dev.sheldan.abstracto.experience.service.management;
 
 import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
+import dev.sheldan.abstracto.core.exception.UserInServerNotFoundException;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.experience.models.database.LeaderBoardEntryResult;
@@ -30,6 +31,16 @@ public class UserExperienceManagementServiceBean implements UserExperienceManage
         return byId.orElseGet(() -> createUserInServer(aUserInAServer));
     }
 
+    @Override
+    public Optional<AUserExperience> findByUserInServerIdOptional(Long userInServerId) {
+       return repository.findById(userInServerId);
+    }
+
+    @Override
+    public AUserExperience findByUserInServerId(Long userInServerId) {
+        return findByUserInServerIdOptional(userInServerId).orElseThrow(() -> new UserInServerNotFoundException(userInServerId));
+    }
+
     /**
      * Initializes the {@link AUserExperience} with default values the following: 0 experience, 0 messages and experience gain enabled
      * @param aUserInAServer The {@link AUserInAServer} to create the {@link AUserExperience} object for.

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/ExperienceRelatedTest.java

@@ -7,14 +7,24 @@ import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
 import dev.sheldan.abstracto.experience.models.database.AExperienceRole;
 import dev.sheldan.abstracto.experience.models.database.AUserExperience;
 import dev.sheldan.abstracto.test.MockUtils;
+import org.mockito.Mock;
+import org.mockito.Mockito;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
+import static org.mockito.Mockito.when;
+
 
 public abstract class ExperienceRelatedTest {
 
+    @Mock
+    private AServer firstServer;
+
+    @Mock
+    private AServer secondServer;
+
     protected List<AUserExperience> getUserExperiences(int count, AServer server) {
         List<AUserExperience> experiences = new ArrayList<>();
         for (int i = 0; i < count; i++) {
@@ -46,12 +56,17 @@ public abstract class ExperienceRelatedTest {
         return new ArrayList<>(Arrays.asList(level0, level1, level2, level3));
     }
 
-    protected List<AExperienceRole> getExperienceRoles(List<AExperienceLevel> levelsWithRoles, AServer server) {
+    protected List<AExperienceRole> getExperienceRoles(List<AExperienceLevel> levelsWithRoles) {
         List<AExperienceRole> roles = new ArrayList<>();
         for (int i = 0; i < levelsWithRoles.size(); i++) {
             AExperienceLevel level = levelsWithRoles.get(i);
-            ARole role = ARole.builder().id((long)i).server(server).build();
+            ARole role = Mockito.mock(ARole.class);
-            roles.add(AExperienceRole.builder().level(level).id(role.getId()).roleServer(server).role(role).build());
+            when(role.getId()).thenReturn((long)i);
+            AExperienceRole experienceRole = Mockito.mock(AExperienceRole.class);
+            when(experienceRole.getLevel()).thenReturn(level);
+            when(experienceRole.getId()).thenReturn((long) i);
+            when(experienceRole.getRole()).thenReturn(role);
+            roles.add(experienceRole);
         }
         return roles;
     }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/service/AUserExperienceServiceBeanTest.java

@@ -1,16 +1,18 @@
 package dev.sheldan.abstracto.experience.service;
 
-import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
 import dev.sheldan.abstracto.core.models.database.*;
 import dev.sheldan.abstracto.core.service.BotService;
 import dev.sheldan.abstracto.core.service.ConfigService;
 import dev.sheldan.abstracto.core.service.MessageService;
 import dev.sheldan.abstracto.core.service.RoleService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
 import dev.sheldan.abstracto.experience.config.features.ExperienceFeatureConfig;
 import dev.sheldan.abstracto.experience.models.LeaderBoard;
 import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
 import dev.sheldan.abstracto.experience.models.RoleCalculationResult;
+import dev.sheldan.abstracto.experience.models.ServerExperience;
 import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
 import dev.sheldan.abstracto.experience.models.database.AExperienceRole;
 import dev.sheldan.abstracto.experience.models.database.AUserExperience;
@@ -81,6 +83,37 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
     @Mock
     private AUserExperienceServiceBean self;
 
+    @Mock
+    private ServerManagementService serverManagementService;
+
+    @Mock
+    private UserInServerManagementService userInServerManagementService;
+
+    @Mock
+    private AUserExperience userExperience;
+
+    @Mock
+    private AUserInAServer aUserInAServer;
+
+    @Mock
+    private AUser user;
+
+    @Mock
+    private ServerExperience serverExperience;
+
+    @Mock
+    private ServerExperience serverExperience2;
+
+    @Mock
+    private AServer server;
+
+    @Mock
+    private Member member;
+
+    private static final Long USER_IN_SERVER_ID = 4L;
+    private static final Long USER_ID = 8L;
+    private static final Long SERVER_ID = 9L;
+
     @Test
     public void testCalculateLevelTooLow() {
         AUserExperience experienceToCalculate = AUserExperience.builder().experience(50L).build();
@@ -123,232 +156,214 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
 
     @Test
     public void testGainExpSingleUserLvlUpOneServerWithoutRole() {
+        /**
+         * In this scenario, the user has a role before, but the config changed, and now there are no experience roles.
+         * Hence the user should lose the experience role.
+         */
+        List<ServerExperience> servers = Arrays.asList(serverExperience);
         List<AExperienceLevel> levels = getLevelConfiguration();
-        List<AServer> servers = getOneServerWithOneUser();
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
-        AServer serverToUse = servers.get(0);
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
-        AUserInAServer userToUse = serverToUse.getUsers().get(0);
         AExperienceRole previousExperienceRole = experienceRoles.get(1);
-        when(botService.isUserInGuild(userToUse)).thenReturn(true);
+        setupSimpleSingleUserTest(levels, experienceRoles);
-        testRoleRelatedScenario(levels, servers, serverToUse, experienceRoles, userToUse, previousExperienceRole);
+        when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
-        verify(roleService, times(1)).removeRoleFromUserFuture(userToUse, previousExperienceRole.getRole());
+        when(botService.isUserInGuild(aUserInAServer)).thenReturn(true);
+        when(roleService.removeRoleFromUserFuture(userExperience.getUser(), userExperience.getCurrentExperienceRole().getRole())).thenReturn(CompletableFuture.completedFuture(null));
+        when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
+        testUnit.handleExperienceGain(servers).join();
+        verify(roleService, times(1)).removeRoleFromUserFuture(aUserInAServer, previousExperienceRole.getRole());
+        verify(roleService, times(0)).addRoleToUserFuture(eq(aUserInAServer), any());
     }
 
     @Test
     public void testLevelUpGainingNewRoleButUserAlreadyHasRole() {
         List<AExperienceLevel> levels = getLevelConfiguration();
-        List<AServer> servers = getOneServerWithOneUser();
+        List<ServerExperience> servers = Arrays.asList(serverExperience);
-        AServer serverToUse = servers.get(0);
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
-        AUserInAServer userToUse = serverToUse.getUsers().get(0);
         AExperienceRole previousExperienceRole = experienceRoles.get(1);
-        AExperienceRole newAwardedRole = testRoleRelatedScenario(levels, servers, serverToUse, experienceRoles, userToUse, previousExperienceRole);
+        setupSimpleSingleUserTest(levels, experienceRoles);
-        verify(roleService, times(0)).addRoleToUser(userToUse, newAwardedRole.getRole());
+        when(userExperience.getExperience()).thenReturn(199L);
-        verify(roleService, times(0)).removeRoleFromUser(userToUse, previousExperienceRole.getRole());
+        AExperienceRole newRole = experienceRoles.get(2);
+        when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
+
+        AExperienceRole newAwardedRole = experienceRoles.get(3);
+        when(roleService.memberHasRole(member, newRole.getRole())).thenReturn(true);
+        when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
+        testUnit.handleExperienceGain(servers).join();
+        verify(roleService, times(0)).addRoleToUser(aUserInAServer, newAwardedRole.getRole());
+        verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, previousExperienceRole.getRole());
     }
 
     @Test
     public void testLevelUpNotGainingNewRole() {
         List<AExperienceLevel> levels = getLevelConfiguration();
-        List<AServer> servers = getOneServerWithOneUser();
+        List<ServerExperience> servers = Arrays.asList(serverExperience);
-        AServer serverToUse = servers.get(0);
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
+        AExperienceRole previousExperienceRole = experienceRoles.get(1);
-        levels.add(AExperienceLevel.builder().level(4).experienceNeeded(400L).build());
+        setupSimpleSingleUserTest(levels, experienceRoles);
-        mockSimpleServer(levels, experienceRoles, serverToUse);
+        when(botService.getMemberInServer(server, aUserInAServer.getUserReference())).thenReturn(member);
-        AUserInAServer userToUse = serverToUse.getUsers().get(0);
+        AExperienceRole newRole = experienceRoles.get(1);
-        AExperienceRole previousExperienceRole = experienceRoles.get(3);
+        when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
-        AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 401L, 3, previousExperienceRole, false);
 
         AExperienceRole newAwardedRole = experienceRoles.get(3);
-        when(userExperienceManagementService.findUserInServer(userToUse)).thenReturn(newUserExperience);
+        when(roleService.memberHasRole(member, newRole.getRole())).thenReturn(true);
-        testUnit.handleExperienceGain(servers);
+        when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
-        verify(roleService, times(0)).removeRoleFromUser(userToUse, previousExperienceRole.getRole());
+        testUnit.handleExperienceGain(servers).join();
-        verify(roleService, times(0)).addRoleToUser(userToUse, newAwardedRole.getRole());
+        verify(roleService, times(0)).addRoleToUser(aUserInAServer, newAwardedRole.getRole());
+        verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, previousExperienceRole.getRole());
     }
 
     @Test
     public void testHandleExperienceForUserNotLevelingUpWithoutExistingRole() {
         List<AExperienceLevel> levels = getLevelConfiguration();
-        List<AServer> servers = getOneServerWithOneUser();
+        List<ServerExperience> servers = Arrays.asList(serverExperience);
-        AServer serverToUse = servers.get(0);
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
+        AExperienceRole previousExperienceRole = null;
-        mockSimpleServer(levels, experienceRoles, serverToUse);
+        when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
-        AUserInAServer userToUse = serverToUse.getUsers().get(0);
+        setupSimpleSingleUserTest(levels, experienceRoles);
-        AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 101L, 1, null, false);
+        when(botService.getMemberInServer(server, aUserInAServer.getUserReference())).thenReturn(member);
-        when(userExperienceManagementService.findUserInServer(userToUse)).thenReturn(newUserExperience);
+        AExperienceRole newRole = experienceRoles.get(1);
-        testUnit.handleExperienceGain(servers);
+        when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
+
+        when(roleService.memberHasRole(member, newRole.getRole())).thenReturn(false);
+        when(roleService.addRoleToUserFuture(userExperience.getUser(), newRole.getRole())).thenReturn(CompletableFuture.completedFuture(null));
+        when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
+        testUnit.handleExperienceGain(servers).join();
+        verify(roleService, times(0)).removeRoleFromUserFuture(eq(aUserInAServer), any());
+        verify(roleService, times(1)).addRoleToUserFuture(eq(aUserInAServer), any());
     }
 
     @Test
     public void handleExpGainWithTooLittleForRole() {
         List<AExperienceLevel> levels = getLevelConfiguration();
-        List<AServer> servers = getOneServerWithOneUser();
+        List<ServerExperience> servers = Arrays.asList(serverExperience);
-        AServer serverToUse = servers.get(0);
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
+        AExperienceRole previousExperienceRole = null;
-        mockSimpleServer(levels, experienceRoles, serverToUse);
+        setupSimpleSingleUserTest(levels, experienceRoles);
-        AUserInAServer userToUse = serverToUse.getUsers().get(0);
+        when(userExperience.getExperience()).thenReturn(50L);
-        AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 50L, 0, null, false);
+        when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
+        when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
+        when(botService.getMemberInServer(server, aUserInAServer.getUserReference())).thenReturn(member);
+        AExperienceRole newRole = null;
+        when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
 
-        when(userExperienceManagementService.findUserInServer(userToUse)).thenReturn(newUserExperience);
+        when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
-        testUnit.handleExperienceGain(servers);
+        testUnit.handleExperienceGain(servers).join();
-        Assert.assertEquals(0, newUserExperience.getCurrentLevel().getLevel().intValue());
+        verify(roleService, times(0)).removeRoleFromUserFuture(eq(aUserInAServer), any());
-        Assert.assertNull(newUserExperience.getCurrentExperienceRole());
+        verify(roleService, times(0)).addRoleToUserFuture(eq(aUserInAServer), any());
     }
 
     @Test
     public void testUserHasExperienceRoleButNotAnymore() {
         List<AExperienceLevel> levels = getLevelConfiguration();
-        List<AServer> servers = getOneServerWithOneUser();
+        List<ServerExperience> servers = Arrays.asList(serverExperience);
-        AServer serverToUse = servers.get(0);
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
+        setupSimpleSingleUserTest(levels, experienceRoles);
-        mockSimpleServer(levels, experienceRoles, serverToUse);
+        when(userExperience.getExperience()).thenReturn(50L);
-        AUserInAServer userToUse = serverToUse.getUsers().get(0);
+        when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
-        Member jdaMember = Mockito.mock(Member.class);
+        AExperienceRole previousExperienceRole = experienceRoles.get(0);
-        when(botService.getMemberInServer(serverToUse, userToUse.getUserReference())).thenReturn(jdaMember);
+        when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
-        AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 50L, 0, experienceRoles.get(0), false);
+        when(botService.getMemberInServer(server, aUserInAServer.getUserReference())).thenReturn(member);
+        AExperienceRole newRole = null;
+        when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
 
-        when(botService.isUserInGuild(userToUse)).thenReturn(true);
+        when(roleService.removeRoleFromUserFuture(eq(aUserInAServer), any())).thenReturn(CompletableFuture.completedFuture(null));
-        when(userExperienceManagementService.findUserInServer(userToUse)).thenReturn(newUserExperience);
+        when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
-        when(roleService.removeRoleFromUserFuture(newUserExperience.getUser(), newUserExperience.getCurrentExperienceRole().getRole())).thenReturn(CompletableFuture.completedFuture(null));
+        testUnit.handleExperienceGain(servers).join();
-        testUnit.handleExperienceGain(servers);
+        verify(roleService, times(0)).addRoleToUserFuture(eq(aUserInAServer), any());
-        verify(roleService, times(1)).removeRoleFromUserFuture(userToUse, experienceRoles.get(0).getRole());
+        verify(roleService, times(1)).removeRoleFromUserFuture(eq(aUserInAServer), any());
-        verify(roleService, times(0)).addRoleToUserFuture(eq(userToUse), any(ARole.class));
     }
 
     @Test
     public void testHandleExperienceGainForGainDisabledForUser() {
         List<AExperienceLevel> levels = getLevelConfiguration();
-        List<AServer> servers = getOneServerWithOneUser();
+        List<ServerExperience> servers = Arrays.asList(serverExperience);
-        AServer serverToUse = servers.get(0);
+        setupServerConfig();
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
+        when(serverManagementService.loadOrCreate(serverExperience.getServerId())).thenReturn(server);
-        mockSimpleServer(levels, experienceRoles, serverToUse);
+        when(experienceLevelManagementService.getLevelConfig()).thenReturn(levels);
-        AUserInAServer userToUse = serverToUse.getUsers().get(0);
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
-        AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 50L, 0, experienceRoles.get(0), true);
+        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
-        when(userExperienceManagementService.findUserInServer(userToUse)).thenReturn(newUserExperience);
+        when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(new ArrayList<>());
-        testUnit.handleExperienceGain(servers);
+        when(userInServerManagementService.loadUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
-        verify(userExperienceManagementService, times(0)).saveUser(eq(newUserExperience));
+        when(user.getId()).thenReturn(USER_ID);
-        verify(roleService, times(0)).removeRoleFromUser(userToUse, experienceRoles.get(0).getRole());
+        when(aUserInAServer.getUserReference()).thenReturn(user);
-        verify(roleService, times(0)).addRoleToUser(eq(userToUse), any(ARole.class));
+        when(aUserInAServer.getUserReference()).thenReturn(user);
-        Assert.assertEquals(0, newUserExperience.getCurrentLevel().getLevel().intValue());
+        when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
-        Assert.assertEquals(experienceRoles.get(0).getRole().getId(), newUserExperience.getCurrentExperienceRole().getRole().getId());
+        when(userExperience.getExperienceGainDisabled()).thenReturn(true);
+
+        when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
+        testUnit.handleExperienceGain(servers).join();
+        verify(roleService, times(0)).removeRoleFromUserFuture(eq(aUserInAServer), any());
+        verify(roleService, times(0)).addRoleToUserFuture(eq(aUserInAServer), any());
     }
 
     @Test
     public void testHandleExperienceGainForGainDisabledForRole() {
         List<AExperienceLevel> levels = getLevelConfiguration();
-        List<AServer> servers = getOneServerWithOneUser();
+        List<ServerExperience> servers = Arrays.asList(serverExperience);
-        AServer serverToUse = servers.get(0);
+        ServerExperience serverToUse = servers.get(0);
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
         mockSimpleServer(levels, experienceRoles, serverToUse);
-        AUserInAServer userToUse = serverToUse.getUsers().get(0);
+        testUnit.handleExperienceGain(servers).join();
-        Member jdaMember = Mockito.mock(Member.class);
+        verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, experienceRoles.get(0).getRole());
-        AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 50L, 0, experienceRoles.get(0), false);
+        verify(roleService, times(0)).addRoleToUser(eq(aUserInAServer), any(ARole.class));
-        when(botService.getMemberInServer(userToUse)).thenReturn(jdaMember);
-        when(roleService.hasAnyOfTheRoles(eq(jdaMember), anyList())).thenReturn(true);
-        testUnit.handleExperienceGain(servers);
-        verify(userExperienceManagementService, times(0)).saveUser(eq(newUserExperience));
-        verify(roleService, times(0)).removeRoleFromUser(userToUse, experienceRoles.get(0).getRole());
-        verify(roleService, times(0)).addRoleToUser(eq(userToUse), any(ARole.class));
-        Assert.assertEquals(0, newUserExperience.getCurrentLevel().getLevel().intValue());
-        Assert.assertEquals(experienceRoles.get(0).getRole().getId(), newUserExperience.getCurrentExperienceRole().getRole().getId());
     }
 
     @Test
     public void testHandleExperienceForUserNotLevelingUpWithExistingRole() {
         List<AExperienceLevel> levels = getLevelConfiguration();
-        List<AServer> servers = getOneServerWithOneUser();
+        List<ServerExperience> servers = Arrays.asList(serverExperience);
-        AServer serverToUse = servers.get(0);
+        when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
-        List<AExperienceRole> experienceRoles = getExperienceRoles(levels, serverToUse);
+        ServerExperience serverToUse = servers.get(0);
-        mockSimpleServer(levels, experienceRoles, serverToUse);
+        List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
-        AUserInAServer userToUse = serverToUse.getUsers().get(0);
+        mockSimpleServer(levels, experienceRoles, serverExperience);
-        AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 101L, 1, experienceRoles.get(1), false);
+        Long userToUse = serverToUse.getUserInServerIds().get(0);
-        when(userExperienceManagementService.findUserInServer(userToUse)).thenReturn(newUserExperience);
+        when(userExperienceManagementService.findByUserInServerIdOptional(userToUse)).thenReturn(Optional.of(userExperience));
+        when(userExperience.getUser()).thenReturn(aUserInAServer);
+        when(userInServerManagementService.loadUser(userToUse)).thenReturn(aUserInAServer);
+        when(aUserInAServer.getUserReference()).thenReturn(user);
+        when(aUserInAServer.getServerReference()).thenReturn(server);
+        when(server.getId()).thenReturn(8L);
+        when(user.getId()).thenReturn(7L);
         CompletableFuture<Void> future = testUnit.handleExperienceGain(servers);
         future.join();
-        verify(roleService, times(0)).removeRoleFromUser(userToUse, experienceRoles.get(0).getRole());
+        verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, experienceRoles.get(0).getRole());
-        verify(roleService, times(0)).addRoleToUser(eq(userToUse), any(ARole.class));
+        verify(roleService, times(0)).addRoleToUser(eq(aUserInAServer), any(ARole.class));
-    }
-
-    @Test
-    public void testSingleUserInMultipleServers() {
-        // The user levels in one server, and does not level in another one
-        List<AExperienceLevel> levels = getLevelConfiguration();
-        List<AServer> servers = getServersWithUserExperience();
-        List<AUserExperience> userExperiences = new ArrayList<>();
-        List<List<AExperienceRole>> allExperienceRoles = new ArrayList<>();
-        List<Integer> userLevels = Arrays.asList(1,2);
-        List<Long> userExperienceValues = Arrays.asList(101L,301L);
-        List<Integer> experienceRoleIndices = Arrays.asList(1, 2);
-        for (int i = 0; i < servers.size(); i++) {
-            AServer aServer = servers.get(i);
-            Integer level = userLevels.get(i);
-            Long experienceValues = userExperienceValues.get(i);
-            List<AExperienceRole> experienceRoles = getExperienceRoles(levels, aServer);
-            mockSimpleServer(levels, experienceRoles, aServer);
-            AUserInAServer userToUse = aServer.getUsers().get(0);
-            AExperienceRole role = experienceRoles.get(experienceRoleIndices.get(i));
-            AUserExperience newUserExperience = mockServerWithSingleUser(levels, aServer, experienceValues, level, role, false);
-            when(userExperienceManagementService.findUserInServer(userToUse)).thenReturn(newUserExperience);
-            userExperiences.add(newUserExperience);
-            allExperienceRoles.add(experienceRoles);
-        }
-        testUnit.handleExperienceGain(servers);
-        for (int i = 0; i < servers.size(); i++) {
-            AServer server = servers.get(i);
-            AUserInAServer userToUse = server.getUsers().get(0);
-            List<AExperienceRole> experienceRoles = allExperienceRoles.get(i);
-            verify(roleService, times(0)).removeRoleFromUser(userToUse, experienceRoles.get(0).getRole());
-            verify(roleService, times(0)).addRoleToUser(eq(userToUse), any(ARole.class));
-        }
     }
 
     @Test
     public void testSyncNoRoleUserGettingRole() {
-        AServer server = MockUtils.getServer(2L);
+        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration());
-        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration(), server);
         AExperienceRole previousRole = null;
         AExperienceRole afterRole = usedExperienceRoles.get(0);
-        Integer removals = 0;
-        Integer adds = 1;
         executeSyncSingleUserTest(server, usedExperienceRoles, previousRole, afterRole);
     }
 
     @Test
     public void testSyncUserLosingRole() {
-        AServer server = MockUtils.getServer(2L);
+        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration());
-        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration(), server);
         AExperienceRole previousRole = usedExperienceRoles.get(0);
         AExperienceRole afterRole = null;
-        Integer removals = 1;
-        Integer adds = 0;
         executeSyncSingleUserTest(server, usedExperienceRoles, previousRole, afterRole);
     }
 
     @Test
     public void testSyncUserKeepRole() {
-        AServer server = MockUtils.getServer(2L);
+        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration());
-        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration(), server);
         AExperienceRole previousRole = usedExperienceRoles.get(0);
         AExperienceRole afterRole = usedExperienceRoles.get(0);
-        Integer removals = 0;
-        Integer adds = 0;
         executeSyncSingleUserTest(server, usedExperienceRoles, previousRole, afterRole);
     }
 
     @Test
     public void testSyncUserChangingRole() {
-        AServer server = MockUtils.getServer(2L);
+        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration());
-        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration(), server);
         AExperienceRole previousRole = usedExperienceRoles.get(0);
         AExperienceRole afterRole = usedExperienceRoles.get(1);
-        Integer removals = 1;
-        Integer adds = 1;
         executeSyncSingleUserTest(server, usedExperienceRoles, previousRole, afterRole);
     }
 
     @Test
     public void testDisablingExperienceForUser() {
-        AServer server = MockUtils.getServer(1L);
         AUserInAServer userObject = MockUtils.getUserObject(2L, server);
         AUserExperience experience = AUserExperience.builder().user(userObject).experienceGainDisabled(false).build();
         when(userExperienceManagementService.findUserInServer(userObject)).thenReturn(experience);
@@ -358,7 +373,6 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
 
     @Test
     public void testDisablingExpForUserWhichHasItDisabled() {
-        AServer server = MockUtils.getServer(1L);
         AUserInAServer userObject = MockUtils.getUserObject(2L, server);
         AUserExperience experience = AUserExperience.builder().user(userObject).experienceGainDisabled(true).build();
         when(userExperienceManagementService.findUserInServer(userObject)).thenReturn(experience);
@@ -368,7 +382,6 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
 
     @Test
     public void testEnablingExperienceForEnabledUser() {
-        AServer server = MockUtils.getServer(1L);
         AUserInAServer userObject = MockUtils.getUserObject(2L, server);
         AUserExperience experience = AUserExperience.builder().user(userObject).experienceGainDisabled(false).build();
         when(userExperienceManagementService.findUserInServer(userObject)).thenReturn(experience);
@@ -378,7 +391,6 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
 
     @Test
     public void testEnablingExpForUserWhichHasItDisabled() {
-        AServer server = MockUtils.getServer(1L);
         AUserInAServer userObject = MockUtils.getUserObject(2L, server);
         AUserExperience experience = AUserExperience.builder().user(userObject).experienceGainDisabled(true).build();
         when(userExperienceManagementService.findUserInServer(userObject)).thenReturn(experience);
@@ -388,13 +400,11 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
 
     @Test
     public void testFindLeaderBoardData() {
-        AServer server = MockUtils.getServer(1L);
         executeLeaderBoardTest(server, 1);
     }
 
     @Test
     public void testFindLeaderBoardDataSecondPage() {
-        AServer server = MockUtils.getServer(1L);
         executeLeaderBoardTest(server, 2);
     }
 
@@ -405,8 +415,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
 
     @Test
     public void testSyncAllUsers() {
-        AServer server = MockUtils.getServer(2L);
+        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration());
-        List<AExperienceRole> usedExperienceRoles = getExperienceRoles(getLevelConfiguration(), server);
         AExperienceRole firstPreviousRole = null;
         AExperienceRole firstAfterRole = usedExperienceRoles.get(0);
         AExperienceRole secondPreviousRole = null;
@@ -447,7 +456,6 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
         int level = 1;
         long messageCount = 1L;
         int rank = 1;
-        AServer server = MockUtils.getServer(2L);
         AUserInAServer userInAServer = MockUtils.getUserObject(1L, server);
         AExperienceLevel level0 = AExperienceLevel.builder().experienceNeeded(200L).level(level).build();
         AUserExperience experienceObj = AUserExperience.builder().experience(experience).user(MockUtils.getUserObject(3L, server)).currentLevel(level0).build();
@@ -470,7 +478,6 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
 
     @Test
     public void testGetRankForUserNotExisting() {
-        AServer server = MockUtils.getServer(2L);
         AUserInAServer userInAServer = MockUtils.getUserObject(1L, server);
         when(userExperienceManagementService.findUserInServer(userInAServer)).thenReturn(null);
         LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(userInAServer);
@@ -483,7 +490,6 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
         long experience = 1L;
         int level = 1;
         long messageCount = 1L;
-        AServer server = MockUtils.getServer(2L);
         AUserInAServer userInAServer = MockUtils.getUserObject(1L, server);
         AExperienceLevel level0 = AExperienceLevel.builder().experienceNeeded(200L).level(level).build();
         AUserExperience experienceObj = AUserExperience.builder().experience(experience).user(MockUtils.getUserObject(3L, server)).messageCount(messageCount).currentLevel(level0).build();
@@ -498,7 +504,6 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
 
     @Test
     public void testSyncRolesWithFeedBack() {
-        AServer server = MockUtils.getServer(1L);
         AChannel channel = AChannel.builder().id(2L).build();
         List<AUserExperience> experiences = getUserExperiences(25, server);
 
@@ -507,13 +512,38 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
 
     @Test
     public void testSyncRolesWithNoUsers() {
-        AServer server = MockUtils.getServer(1L);
         AChannel channel = AChannel.builder().id(2L).build();
         List<AUserExperience> experiences = new ArrayList<>();
 
         checkStatusMessages(server, channel, experiences, 1);
     }
 
+    private void setupServerConfig() {
+        when(configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, serverExperience.getServerId())).thenReturn(20L);
+        when(configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, serverExperience.getServerId())).thenReturn(50L);
+        when(configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverExperience.getServerId())).thenReturn(1.2);
+    }
+
+    private void setupSimpleSingleUserTest(List<AExperienceLevel> levels, List<AExperienceRole> experienceRoles) {
+        setupServerConfig();
+        when(serverManagementService.loadOrCreate(serverExperience.getServerId())).thenReturn(server);
+        when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
+        when(experienceLevelManagementService.getLevelConfig()).thenReturn(levels);
+        when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
+        when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(new ArrayList<>());
+        when(userInServerManagementService.loadUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
+        when(user.getId()).thenReturn(USER_ID);
+        when(aUserInAServer.getUserReference()).thenReturn(user);
+        when(botService.getMemberInServer(server, aUserInAServer.getUserReference())).thenReturn(member);
+        when(userExperience.getExperience()).thenReturn(500L);
+        when(userExperience.getUser()).thenReturn(aUserInAServer);
+        when(aUserInAServer.getUserReference()).thenReturn(user);
+        when(aUserInAServer.getServerReference()).thenReturn(server);
+        when(botService.isUserInGuild(userExperience.getUser())).thenReturn(true);
+        when(server.getId()).thenReturn(SERVER_ID);
+        when(user.getId()).thenReturn(USER_ID);
+    }
+
     private void checkStatusMessages(AServer server, AChannel channel, List<AUserExperience> experiences, int messageCount) {
         when(userExperienceManagementService.loadAllUsers(server)).thenReturn(experiences);
         MessageToSend statusMessage = MessageToSend.builder().message("text").build();
@@ -532,13 +562,12 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
         List<AUserExperience> experiences = Arrays.asList(experience);
 
         List<AUserInAServer> users = experiences.stream().map(AUserExperience::getUser).collect(Collectors.toList());
-        Member firstMember = Mockito.mock(Member.class);
+        when(botService.getMemberInServer(server, users.get(0).getUserReference())).thenReturn(member);
-        when(botService.getMemberInServer(server, users.get(0).getUserReference())).thenReturn(firstMember);
         experience.setCurrentExperienceRole(previousRole);
         when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
         when(experienceRoleService.calculateRole(usedExperienceRoles, experience.getLevelOrDefault())).thenReturn(afterRole);
-        when(botService.getMemberInServer(server, experience.getUser().getUserReference())).thenReturn(firstMember);
+        when(botService.getMemberInServer(server, experience.getUser().getUserReference())).thenReturn(member);
-        users.forEach(aUserInAServer -> when(botService.isUserInGuild(aUserInAServer)).thenReturn(true));
+        users.forEach(innerUser -> when(botService.isUserInGuild(innerUser)).thenReturn(true));
         if(afterRole != null) {
             when(roleService.addRoleToUserFuture(experience.getUser(), afterRole.getRole())).thenReturn(CompletableFuture.completedFuture(null));
         }
@@ -547,7 +576,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
         }
         if(afterRole != null && previousRole != null) {
             boolean sameRole = previousRole.getRole().getId().equals(afterRole.getRole().getId());
-            when(roleService.memberHasRole(firstMember, afterRole.getRole())).thenReturn(sameRole);
+            when(roleService.memberHasRole(member, afterRole.getRole())).thenReturn(sameRole);
         }
         CompletableFuture<RoleCalculationResult> calculationFuture = testUnit.syncForSingleUser(experience);
         RoleCalculationResult result = calculationFuture.join();
@@ -575,55 +604,15 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
         Assert.assertEquals(pageSize, entries.size());
     }
 
-    private AExperienceRole testRoleRelatedScenario(List<AExperienceLevel> levels, List<AServer> servers, AServer serverToUse, List<AExperienceRole> experienceRoles, AUserInAServer userToUse, AExperienceRole previousExperienceRole) {
+    private void mockSimpleServer(List<AExperienceLevel> levels, List<AExperienceRole> experienceRoles, ServerExperience serverExperience) {
-        mockSimpleServer(levels, experienceRoles, serverToUse);
+        when(configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, serverExperience.getServerId())).thenReturn(20L);
-        Member jdaMember = Mockito.mock(Member.class);
+        when(configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, serverExperience.getServerId())).thenReturn(50L);
-        when(botService.getMemberInServer(serverToUse, userToUse.getUserReference())).thenReturn(jdaMember);
+        when(configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverExperience.getServerId())).thenReturn(1.2);
-        AUserExperience newUserExperience = mockServerWithSingleUser(levels, serverToUse, 301L, 1, previousExperienceRole, false);
+        when(serverManagementService.loadOrCreate(serverExperience.getServerId())).thenReturn(server);
-
-        AExperienceRole newAwardedRole = experienceRoles.get(3);
-        when(roleService.removeRoleFromUserFuture(newUserExperience.getUser(), newUserExperience.getCurrentExperienceRole().getRole())).thenReturn(CompletableFuture.completedFuture(null));
-        when(userExperienceManagementService.findUserInServer(userToUse)).thenReturn(newUserExperience);
-        testUnit.handleExperienceGain(servers).join();
-        return newAwardedRole;
-    }
-
-    private AUserExperience mockServerWithSingleUser(List<AExperienceLevel> levels, AServer serverToUse, Long experience, Integer currentLevelValue, AExperienceRole role, boolean hasExpDisabled) {
-        Optional<AExperienceLevel> first = levels.stream().filter(level -> level.getLevel().equals(currentLevelValue)).findFirst();
-        if(first.isPresent()) {
-            AExperienceLevel currentLevel = first.get();
-            AUserInAServer firstUser = serverToUse.getUsers().get(0);
-            return mockUser(experience, currentLevel, firstUser, hasExpDisabled, role);
-        }
-        throw new AbstractoRunTimeException("No level found");
-    }
-
-    private AUserExperience mockUser(Long experience, AExperienceLevel currentLevel, AUserInAServer firstUser, boolean hasExpDisabled, AExperienceRole currentRole) {
-        return AUserExperience.builder().currentLevel(currentLevel).experience(experience).user(firstUser).experienceGainDisabled(hasExpDisabled).currentExperienceRole(currentRole).messageCount(0L).build();
-    }
-
-    private void mockSimpleServer(List<AExperienceLevel> levels, List<AExperienceRole> experienceRoles, AServer server) {
-        when(configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, server.getId())).thenReturn(20L);
-        when(configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, server.getId())).thenReturn(50L);
-        when(configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, server.getId())).thenReturn(1.2);
         when(experienceLevelManagementService.getLevelConfig()).thenReturn(levels);
         when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
         when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(new ArrayList<>());
     }
 
-    private List<AServer> getOneServerWithOneUser() {
-        AServer server = MockUtils.getServer(3L);
-        MockUtils.getUserObject(3L, server);
-        return Arrays.asList(server);
-    }
-
-    private List<AServer> getServersWithUserExperience() {
-        AServer server = MockUtils.getServer(3L);
-        AServer otherServer = MockUtils.getServer(3L);
-        MockUtils.getUserObject(3L, server);
-        MockUtils.getUserObject(4L, otherServer);
-
-        return Arrays.asList(server, otherServer);
-    }
 
 }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/models/ExperienceGainResult.java

@@ -15,4 +15,6 @@ public class ExperienceGainResult {
     private Long newExperience;
     private Integer newLevel;
     private Long newMessageCount;
+    @Builder.Default
+    private boolean createUserExperience = false;
 }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/models/ServerExperience.java

@@ -0,0 +1,17 @@
+package dev.sheldan.abstracto.experience.models;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Getter
+@Setter
+@Builder
+public class ServerExperience {
+    private Long serverId;
+    @Builder.Default
+    private List<Long> userInServerIds = new ArrayList<>();
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/service/AUserExperienceService.java

@@ -7,6 +7,7 @@ import dev.sheldan.abstracto.core.utils.CompletableFutureList;
 import dev.sheldan.abstracto.experience.models.LeaderBoard;
 import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
 import dev.sheldan.abstracto.experience.models.RoleCalculationResult;
+import dev.sheldan.abstracto.experience.models.ServerExperience;
 import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
 import dev.sheldan.abstracto.experience.models.database.AExperienceRole;
 import dev.sheldan.abstracto.experience.models.database.AUserExperience;
@@ -35,7 +36,7 @@ public interface AUserExperienceService {
      * containing a list of {@link AUserInAServer} which should gain experience in the minute used as key in the HashMap
      * @return
      */
-    Map<Long, List<AServer>> getRuntimeExperience();
+    Map<Long, List<ServerExperience>> getRuntimeExperience();
 
     /**
      * Calculates the appropriate level of the given {@link AUserExperience} according to the given {@link AExperienceLevel}
@@ -64,7 +65,7 @@ public interface AUserExperienceService {
      * of each user by 1.
      * @param serverExp The list of {@link AServer} containing the users which get experience
      */
-    CompletableFuture<Void> handleExperienceGain(List<AServer> serverExp);
+    CompletableFuture<Void> handleExperienceGain(List<ServerExperience> serverExp);
 
     /**
      * Calculates the currently appropriate {@link AExperienceRole} for the given user and updates the role on the

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-int/src/main/java/dev/sheldan/abstracto/experience/service/management/UserExperienceManagementService.java

@@ -7,6 +7,7 @@ import dev.sheldan.abstracto.experience.models.database.LeaderBoardEntryResult;
 import dev.sheldan.abstracto.experience.models.database.AUserExperience;
 
 import java.util.List;
+import java.util.Optional;
 
 /**
  * Service used to manage the record in the {@link AUserExperience} table
@@ -19,6 +20,9 @@ public interface UserExperienceManagementService {
      */
     AUserExperience findUserInServer(AUserInAServer aUserInAServer);
 
+    Optional<AUserExperience> findByUserInServerIdOptional(Long userInServerId);
+    AUserExperience findByUserInServerId(Long userInServerId);
+
     /**
      * Creates a {@link AUserExperience} object with the default values (0 xp, 0 messages) for the given {@link AUserInAServer} object.
      * @param aUserInAServer The {@link AUserInAServer} to create the {@link AUserExperience} object for.

abstracto-application/abstracto-modules/modmail/modmail-int/src/main/java/dev/sheldan/abstracto/modmail/models/template/ModMailCategoryValidationErrorModel.java

@@ -5,8 +5,6 @@ import lombok.Builder;
 import lombok.Getter;
 import lombok.Setter;
 
-import java.util.HashMap;
-
 /**
  * This model is used when the category for creating mod mail threads is not properly setup
  * and when the feature is enabled via command. This will be rendered as a simple additional line of validation errors
@@ -20,13 +18,11 @@ public class ModMailCategoryValidationErrorModel implements ValidationErrorModel
 
     @Override
     public String getTemplateName() {
-        return "modmail_category_not_setup";
+        return "setup_modmail_category_not_setup";
     }
 
     @Override
     public Object getTemplateModel() {
-        HashMap<String, Long> params = new HashMap<>();
+        return new Object();
-        params.put("categoryId", currentCategoryId);
-        return params;
     }
 }

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/config/Setup.java

@@ -58,11 +58,12 @@ public class Setup extends AbstractConditionableCommand {
     public CommandConfiguration getConfiguration() {
         Parameter newPrefixParameter = Parameter.builder().name("feature").type(String.class).build();
         List<Parameter> parameters = Arrays.asList(newPrefixParameter);
-        HelpInfo helpInfo = HelpInfo.builder().build();
+        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
         return CommandConfiguration.builder()
                 .name("setup")
                 .module(ConfigModuleInterface.CONFIG)
                 .parameters(parameters)
+                .templated(true)
                 .async(true)
                 .supportsEmbedException(true)
                 .help(helpInfo)

abstracto-application/core/core-impl/src/main/resources/migrations/1.0-core/core-functions/counter_function.xml

@@ -6,9 +6,9 @@
                    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog ../../dbchangelog-3.8.xsd
     http://www.liquibase.org/xml/ns/dbchangelog-ext ../../dbchangelog-3.8.xsd
     http://www.liquibase.org/xml/ns/pro ../../dbchangelog-3.8.xsd" >
-    <changeSet author="me" id="counter_function" dbms="postgres">
+    <changeSet author="Sheldan" id="counter_function" dbms="postgresql">
         <sqlFile encoding="utf8" path="sql/counter_function.sql"
                  relativeToChangelogFile="true"
-                 stripComments="false"/>
+                 splitStatements="false"/>
     </changeSet>
 </databaseChangeLog>

abstracto-application/core/core-impl/src/main/resources/migrations/1.0-core/core-functions/sql/counter_function.sql

@@ -6,23 +6,23 @@ BEGIN
     SELECT count(1)
     FROM COUNTER
     INTO v_exists
-    WHERE server_reference = p_server_id
+    WHERE server_id = p_server_id
     AND counter_key = p_counter_key;
 
     IF v_exists >= 1 THEN
         SELECT MAX(counter) + 1
         INTO v_next_count
         FROM counter
-        WHERE server_reference = p_server_id
+        WHERE server_id = p_server_id
         AND counter_key = p_counter_key;
 
         UPDATE counter
         SET counter = v_next_count
-        WHERE server_reference = p_server_id
+        WHERE server_id = p_server_id
         AND counter_key = p_counter_key;
     ELSE
         v_next_count := 1;
-        INSERT INTO counter (counter_key, server_reference, counter)
+        INSERT INTO counter (counter_key, server_id, counter)
             VALUES (p_counter_key, p_server_id, v_next_count);
     END IF;
     RETURN v_next_count;

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/models/database/Counter.java

@@ -22,7 +22,7 @@ public class Counter {
 
     @ManyToOne(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
     @MapsId("serverId")
-    @JoinColumn(name = "serverReference", referencedColumnName = "id", nullable = false)
+    @JoinColumn(name = "server_id", referencedColumnName = "id", nullable = false)
     private AServer server;
 
     @Column(name = "counter")

abstracto-application/core/core-interface/src/main/java/dev/sheldan/abstracto/core/models/exception/DurationFormatExceptionModel.java

@@ -8,6 +8,7 @@ import java.io.Serializable;
 import java.util.List;
 
 @Setter
+@Getter
 @Builder
 public class DurationFormatExceptionModel implements Serializable {
     private final String invalidFormat;

abstracto-application/templating/templating-impl/src/main/resources/migrations/1.0-templating/templating-tables/auto_load_macro.xml

@@ -14,8 +14,9 @@
         </createTable>
     </changeSet>
 
+    <!-- TODO doesnt work for initial config, because auto load macros are defined, but templates not present yet
     <changeSet author="Sheldan" id="auto_load_macro-fk_assignable_role_emote">
         <addForeignKeyConstraint baseColumnNames="key" baseTableName="auto_load_macro" constraintName="fk_auto_load_macro_template" deferrable="false" initiallyDeferred="false" onDelete="NO ACTION" onUpdate="NO ACTION" referencedColumnNames="key" referencedTableName="template" validate="true"/>
     </changeSet>
-
+    -->
 </databaseChangeLog>