[AB-247/AB-252] fixing issue with set experience role failing to consider the correct experience roles

adding levelRoles command ignoring bots from experience gain adding a bit more logging to user experience handling
2026-04-18 04:50:38 +00:00 · 2021-05-26 01:22:37 +02:00
parent c4fe73b3f8
commit 184271ff7c
27 changed files with 353 additions and 126 deletions
--- a/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/command/LevelRoles.java
+++ b/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/command/LevelRoles.java
@@ -0,0 +1,73 @@
+package dev.sheldan.abstracto.experience.command;
+
+import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
+import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
+import dev.sheldan.abstracto.core.command.config.HelpInfo;
+import dev.sheldan.abstracto.core.command.config.Parameter;
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
+import dev.sheldan.abstracto.experience.config.ExperienceFeatureDefinition;
+import dev.sheldan.abstracto.experience.model.template.LevelRole;
+import dev.sheldan.abstracto.experience.model.template.LevelRolesModel;
+import dev.sheldan.abstracto.experience.service.ExperienceRoleService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+
+@Component
+public class LevelRoles extends AbstractConditionableCommand {
+
+    @Autowired
+    private ExperienceRoleService experienceRoleService;
+
+    @Autowired
+    private ServerManagementService serverManagementService;
+
+    @Autowired
+    private ChannelService channelService;
+
+    private static final String LEVEL_ROLES_TEMPLATE_KEY = "levelRoles_response";
+
+    @Override
+    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
+        AServer server = serverManagementService.loadServer(commandContext.getGuild());
+        List<LevelRole> levelRoles = experienceRoleService.loadLevelRoleConfigForServer(server);
+        levelRoles = levelRoles.stream().sorted(Comparator.comparingInt(LevelRole::getLevel).reversed()).collect(Collectors.toList());
+        LevelRolesModel model = LevelRolesModel
+                .builder()
+                .levelRoles(levelRoles)
+                .build();
+        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInTextChannelList(LEVEL_ROLES_TEMPLATE_KEY, model, commandContext.getChannel()))
+                .thenApply(unused -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        List<Parameter> parameters = new ArrayList<>();
+        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        return CommandConfiguration.builder()
+                .name("levelRoles")
+                .module(ExperienceModuleDefinition.EXPERIENCE)
+                .async(true)
+                .templated(true)
+                .supportsEmbedException(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return ExperienceFeatureDefinition.EXPERIENCE;
+    }
+}
--- a/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/command/UnSetExpRole.java
+++ b/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/command/UnSetExpRole.java
@@ -10,12 +10,16 @@ import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.service.management.RoleManagementService;
 import dev.sheldan.abstracto.experience.config.ExperienceFeatureDefinition;
+import dev.sheldan.abstracto.experience.exception.ExperienceRoleNotFoundException;
+import dev.sheldan.abstracto.experience.model.database.AExperienceRole;
 import dev.sheldan.abstracto.experience.service.ExperienceRoleService;
+import dev.sheldan.abstracto.experience.service.management.ExperienceRoleManagementService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;

 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 import java.util.concurrent.CompletableFuture;

 /**
@@ -31,13 +35,20 @@ public class UnSetExpRole extends AbstractConditionableCommand {
    @Autowired
    private RoleManagementService roleManagementService;

+    @Autowired
+    private ExperienceRoleManagementService experienceRoleManagementService;
+
    @Override
    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
        ARole role = (ARole) commandContext.getParameters().getParameters().get(0);
        ARole actualRole = roleManagementService.findRole(role.getId());
        // do not check for the existence of the role, because if the role was deleted, users should be able
        // to get rid of it in the configuration
-        return experienceRoleService.unsetRole(actualRole, commandContext.getChannel().getIdLong())
+        Optional<AExperienceRole> experienceRole = experienceRoleManagementService.getRoleInServerOptional(actualRole);
+        if(!experienceRole.isPresent()) {
+            throw new ExperienceRoleNotFoundException();
+        }
+        return experienceRoleService.unsetRoles(actualRole, commandContext.getChannel().getIdLong())
                .thenApply(aVoid -> CommandResult.fromSuccess());
    }

--- a/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/listener/ExperienceTrackerListener.java
+++ b/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/listener/ExperienceTrackerListener.java
@@ -31,7 +31,7 @@ public class ExperienceTrackerListener implements AsyncMessageReceivedListener {
    @Override
    public DefaultListenerResult execute(MessageReceivedModel model) {
        Message message = model.getMessage();
-        if(!message.isFromGuild() || message.isWebhookMessage() || message.getType().isSystem()) {
+        if(!message.isFromGuild() || message.isWebhookMessage() || message.getType().isSystem() || message.getAuthor().isBot()) {
            return DefaultListenerResult.IGNORED;
        }
        AUserInAServer cause = userInServerManagementService.loadOrCreateUser(model.getServerId(), model.getMessage().getAuthor().getIdLong());
--- a/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/AUserExperienceServiceBean.java
+++ b/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/AUserExperienceServiceBean.java
@@ -94,24 +94,26 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
        try {
            Long minute = Instant.now().getEpochSecond() / 60;
            Map<Long, List<ServerExperience>> runtimeExperience = runTimeExperienceService.getRuntimeExperience();
+            Long serverId = userInAServer.getServerReference().getId();
+            Long userInServerId = userInAServer.getUserInServerId();
            if(runtimeExperience.containsKey(minute)) {
                log.debug("Minute {} already tracked, adding user {} in server {}.",
-                        minute, userInAServer.getUserReference().getId(), userInAServer.getServerReference().getId());
+                        minute, userInAServer.getUserReference().getId(), serverId);
                List<ServerExperience> existing = runtimeExperience.get(minute);
                for (ServerExperience server : existing) {
-                    if (server.getServerId().equals(userInAServer.getServerReference().getId()) && server.getUserInServerIds().stream().noneMatch(userInAServer1 -> userInAServer.getUserInServerId().equals(userInAServer1))) {
-                        server.getUserInServerIds().add(userInAServer.getUserInServerId());
+                    if (server.getServerId().equals(serverId) && server.getUserInServerIds().stream().noneMatch(userInServerId::equals)) {
+                        server.getUserInServerIds().add(userInServerId);
                        break;
                    }
                }

            } else {
-                log.debug("Minute {} did not exist yet. Creating new entry for user {} in server {}.", minute, userInAServer.getUserReference().getId(), userInAServer.getServerReference().getId());
+                log.debug("Minute {} did not exist yet. Creating new entry for user {} in server {}.", minute, userInAServer.getUserReference().getId(), serverId);
                ServerExperience serverExperience = ServerExperience
                        .builder()
-                        .serverId(userInAServer.getServerReference().getId())
+                        .serverId(serverId)
                        .build();
-                serverExperience.getUserInServerIds().add(userInAServer.getUserInServerId());
+                serverExperience.getUserInServerIds().add(userInServerId);
                runtimeExperience.put(minute, new ArrayList<>(Arrays.asList(serverExperience)));
            }
        } finally {
@@ -180,7 +182,6 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
        SystemConfigProperty defaultMinExp = defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MIN_EXP_KEY);
        SystemConfigProperty defaultMaxExp = defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MAX_EXP_KEY);
        AServer server = serverManagementService.loadOrCreate(serverId);
-        log.info("Handling {} experience for server {}", memberFutures.size(), serverId);
        int minExp = configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, serverId, defaultMinExp.getLongValue()).intValue();
        int maxExp = configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, serverId, defaultMaxExp.getLongValue()).intValue();
        Double multiplier = configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverId, defaultExpMultiplier.getDoubleValue());
@@ -190,18 +191,21 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
        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()));
+        log.info("Handling {} experiences for server {}. Using {} roles.", memberFutures.size(), serverId, roles.size());
        memberFutures.forEach(future -> {
            if(!future.isCompletedExceptionally()) {
                Integer gainedExperience = iterator.next();
                gainedExperience = (int) Math.floor(gainedExperience * multiplier);
                Member member = future.join();
                AUserInAServer userInAServer = userInServerManagementService.loadOrCreateUser(member);
+                Long userInServerId = userInAServer.getUserInServerId();
                if(!roleService.hasAnyOfTheRoles(member, disabledRoles)) {
-                    log.debug("Handling {}. The user gains {}", userInAServer.getUserReference().getId(), gainedExperience);
+                    log.debug("Handling {}. The user might gain {}.", userInServerId, gainedExperience);
                    Optional<AUserExperience> aUserExperienceOptional = userExperienceManagementService.findByUserInServerIdOptional(userInAServer.getUserInServerId());
                    if(aUserExperienceOptional.isPresent()) {
                        AUserExperience aUserExperience = aUserExperienceOptional.get();
                        if(Boolean.FALSE.equals(aUserExperience.getExperienceGainDisabled())) {
+                            log.debug("User {} will gain experience.", userInServerId);
                            Long newExperienceCount = aUserExperience.getExperience() + gainedExperience.longValue();
                            AExperienceLevel newLevel = calculateLevel(levels, newExperienceCount);
                            CompletableFuture<RoleCalculationResult> resultFuture = updateUserRole(aUserExperience, roles, newLevel.getLevel());
@@ -240,7 +244,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
                        futures.add(resultFuture);
                    }
                } else {
-                    log.info("User {} has a role which makes the user unable to gain experience.", userInAServer.getUserInServerId());
+                    log.debug("User {} has a role which makes the user unable to gain experience.", userInAServer.getUserInServerId());
                }
            }
        });
@@ -296,7 +300,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
            AUserExperience userExperience;
            if(experienceGainResult.isCreateUserExperience()) {
                userExperience = userExperienceManagementService.createUserInServer(user);
-                log.info("Creating new experience user {}", experienceGainResult.getUserInServerId());
+                log.info("Creating new experience user for user in server {}.", experienceGainResult.getUserInServerId());
            } else {
                userExperience = userExperienceManagementService.findByUserInServerId(experienceGainResult.getUserInServerId());
            }
@@ -346,7 +350,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
            log.debug("User {} in server {} does not have an experience role, according to new calculation.",
                    user.getUserReference().getId(), serverId);
            // if the user has a experience role currently, remove it
-            if(!currentlyHasNoExperienceRole){
+            if(!currentlyHasNoExperienceRole && !userExperience.getCurrentExperienceRole().getRole().getDeleted()){
                return roleService.removeRoleFromUserFuture(user, userExperience.getCurrentExperienceRole().getRole())
                        .thenApply(returnNullRole);
            }
@@ -373,16 +377,17 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
            // if the roles changed or
            // the user does not have the new target role already
            // the user still has the old role
-            if((!userHasRoleAlready || userHasOldRole)) {
-                log.info("User {} in server {} gets a new role {} because of experience.", userId, serverId, roleId);
+            if(!userHasRoleAlready || userHasOldRole) {
                CompletableFuture<Void> removalFuture;
                if(userHasOldRole && rolesChanged) {
+                    log.info("User {} in server {} loses experience role {}.", userId, serverId, oldUserExperienceRoleId);
                    removalFuture = roleService.removeRoleFromMemberAsync(member, oldUserExperienceRoleId);
                } else {
                    removalFuture = CompletableFuture.completedFuture(null);
                }
                CompletableFuture<Void> addRoleFuture;
                if(!userHasRoleAlready) {
+                    log.info("User {} in server {} gets a new role {} because of experience.", userId, serverId, roleId);
                    addRoleFuture = roleService.addRoleToMemberFuture(member, roleId);
                } else {
                    addRoleFuture = CompletableFuture.completedFuture(null);
@@ -403,7 +408,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
        roles.sort(Comparator.comparing(role -> role.getLevel().getLevel()));
        for (int i = 0; i < aUserExperiences.size(); i++) {
            AUserExperience userExperience = aUserExperiences.get(i);
-            log.debug("Synchronizing {} out of {}", i, aUserExperiences.size());
+            log.info("Synchronizing {} out of {}. User in Server {}.", i, aUserExperiences.size(), userExperience.getUser().getUserInServerId());
            results.add(updateUserRole(userExperience, roles, userExperience.getCurrentLevel().getLevel()));
        }
        return results;
@@ -424,7 +429,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {

    /**
     * Updates the actually stored experience roles in the database
-     * @param results The list of {@link RoleCalculationResult} which should be applied
+     * @param results The list of {@link RoleCalculationResult results} which should be applied
     */
    @Transactional
    public void syncRolesInStorage(List<RoleCalculationResult> results) {
@@ -461,12 +466,13 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
        int interval = Math.min(Math.max(experiences.size() / 10, 1), 100);
        for (int i = 0; i < experiences.size(); i++) {
            if((i % interval) == 1) {
-                log.debug("Updating feedback message with new index {} out of {}", i, experiences.size());
+                log.info("Updating feedback message with new index {} out of {}.", i, experiences.size());
                status = getUserSyncStatusUpdateModel(i, experiences.size(), serverId);
                messageService.updateStatusMessage(channel, statusMessage.getIdLong(), status);
            }
-            futures.add(toExecute.apply(experiences.get(i)));
-            log.debug("Synchronizing {} out of {}", i, experiences.size());
+            AUserExperience userExperience = experiences.get(i);
+            futures.add(toExecute.apply(userExperience));
+            log.debug("Synchronizing {} out of {}. User in server ID {}.", i, experiences.size(), userExperience.getUser().getUserInServerId());
        }
        status = getUserSyncStatusUpdateModel(experiences.size(), experiences.size(), serverId);
        messageService.updateStatusMessage(channel, statusMessage.getIdLong(), status);
@@ -483,8 +489,8 @@ public class AUserExperienceServiceBean implements AUserExperienceService {

    @Override
    public void enableExperienceForUser(AUserInAServer userInAServer) {
-        AUserExperience userExperience = userExperienceManagementService.findUserInServer(userInAServer);
        log.info("Enabling experience gain for user {} in server {}.", userInAServer.getUserReference().getId(), userInAServer.getServerReference().getId());
+        AUserExperience userExperience = userExperienceManagementService.findUserInServer(userInAServer);
        userExperience.setExperienceGainDisabled(false);
    }

@@ -503,7 +509,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
    @Override
    public CompletableFuture<RoleCalculationResult> syncForSingleUser(AUserExperience userExperience) {
        AUserInAServer user = userExperience.getUser();
-        log.info("Synchronizing for user {} in server {}", user.getUserReference().getId(), user.getServerReference().getId());
+        log.info("Synchronizing for user {} in server {}.", user.getUserReference().getId(), user.getServerReference().getId());
        List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(user.getServerReference());
        roles.sort(Comparator.comparing(role -> role.getLevel().getLevel()));
        return updateUserRole(userExperience, roles, userExperience.getLevelOrDefault());
--- a/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/ExperienceLevelServiceBean.java
+++ b/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/ExperienceLevelServiceBean.java
@@ -57,7 +57,7 @@ public class ExperienceLevelServiceBean implements ExperienceLevelService {

    @Override
    public Long calculateExperienceToNextLevel(Integer level, Long currentExperience) {
-        AExperienceLevel nextLevel = experienceLevelManagementService.getLevel(level + 1)
+        AExperienceLevel nextLevel = experienceLevelManagementService.getLevelOptional(level + 1)
                .orElseThrow(() -> new AbstractoRunTimeException(String.format("Could not find level %s", level)));
        return nextLevel.getExperienceNeeded() - currentExperience;
    }
--- a/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/ExperienceRoleServiceBean.java
+++ b/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/ExperienceRoleServiceBean.java
@@ -3,6 +3,7 @@ package dev.sheldan.abstracto.experience.service;
 import dev.sheldan.abstracto.core.models.database.AChannel;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.RoleService;
 import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
 import dev.sheldan.abstracto.core.service.management.RoleManagementService;
 import dev.sheldan.abstracto.core.utils.CompletableFutureList;
@@ -10,6 +11,7 @@ import dev.sheldan.abstracto.experience.model.RoleCalculationResult;
 import dev.sheldan.abstracto.experience.model.database.AExperienceLevel;
 import dev.sheldan.abstracto.experience.model.database.AExperienceRole;
 import dev.sheldan.abstracto.experience.model.database.AUserExperience;
+import dev.sheldan.abstracto.experience.model.template.LevelRole;
 import dev.sheldan.abstracto.experience.service.management.ExperienceLevelManagementService;
 import dev.sheldan.abstracto.experience.service.management.ExperienceRoleManagementService;
 import lombok.extern.slf4j.Slf4j;
@@ -18,9 +20,7 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;

-import java.util.Comparator;
-import java.util.List;
-import java.util.Optional;
+import java.util.*;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;

@@ -46,6 +46,9 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
    @Autowired
    private ChannelManagementService channelManagementService;

+    @Autowired
+    private RoleService roleService;
+
    /**
     * UnSets the current configuration for the passed level, and sets the {@link ARole} to be used for this level
     * in the given {@link AServer}
@@ -55,14 +58,43 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
    @Override
    public CompletableFuture<Void> setRoleToLevel(Role role, Integer level, Long channelId) {
        Long roleId = role.getIdLong();
-        ARole aRole = roleManagementService.findRole(roleId);
-        return unsetRole(aRole, channelId).thenAccept(aVoid ->
+        ARole aRoleToSet = roleManagementService.findRole(roleId);
+        List<AExperienceRole> experienceRoles = getExperienceRolesAtLevel(level, aRoleToSet.getServer());
+        List<ARole> rolesToUnset = experienceRoles.stream().map(AExperienceRole::getRole).collect(Collectors.toList());
+        if(rolesToUnset.size() == 1 && rolesToUnset.contains(aRoleToSet)) {
+            return CompletableFuture.completedFuture(null);
+        }
+        if(!rolesToUnset.contains(aRoleToSet)) {
+            rolesToUnset.add(aRoleToSet);
+        }
+        AExperienceLevel experienceLevel;
+        if(!experienceRoles.isEmpty()) {
+            experienceLevel = experienceRoles.get(0).getLevel();
+        } else {
+            experienceLevel = experienceLevelService.getLevel(level);
+        }
+        AExperienceRole newExperienceRole = experienceRoleManagementService.setLevelToRole(experienceLevel, aRoleToSet);
+        Long newlyCreatedExperienceRoleId = newExperienceRole.getId();
+        CompletableFuture<Void> future = new CompletableFuture<>();
+        unsetRoles(rolesToUnset, channelId, newExperienceRole).thenAccept(aVoid ->
            self.unsetRoleInDb(level, roleId)
-        );
+        ).thenAccept(unused -> future.complete(null)).exceptionally(throwable -> {
+            self.deleteExperienceRoleViaId(newlyCreatedExperienceRoleId);
+            future.completeExceptionally(throwable);
+            return null;
+        });
+
+        return future;
+    }
+
+    @Transactional
+     public void deleteExperienceRoleViaId(Long newlyCreatedExperienceRoleId) {
+        AExperienceRole reLoadedRole = experienceRoleManagementService.getExperienceRoleById(newlyCreatedExperienceRoleId);
+        experienceRoleManagementService.unsetRole(reLoadedRole);
    }

    /**
-     * Removes all previous defined {@link AExperienceRole experienceRoles} from the given leve and sets the {@link ARole}
+     * Removes all previous defined {@link AExperienceRole experienceRoles} from the given level and sets the {@link ARole}
     * (defined by its ID) to the level.
     * @param level The level which the {@link ARole role} should be set to
     * @param roleId The ID of the {@link Role} which should have its level set
@@ -70,9 +102,9 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
    @Transactional
    public void unsetRoleInDb(Integer level, Long roleId) {
        log.info("Unsetting role {} from level {}.", roleId, level);
-        AExperienceLevel experienceLevel = experienceLevelService.getLevel(level).orElseThrow(() -> new IllegalArgumentException(String.format("Could not find level %s", level)));
+        AExperienceLevel experienceLevel = experienceLevelService.getLevelOptional(level).orElseThrow(() -> new IllegalArgumentException(String.format("Could not find level %s", level)));
        ARole loadedRole = roleManagementService.findRole(roleId);
-        experienceRoleManagementService.removeAllRoleAssignmentsForLevelInServer(experienceLevel, loadedRole.getServer());
+        experienceRoleManagementService.removeAllRoleAssignmentsForLevelInServerExceptRole(experienceLevel, loadedRole.getServer(), loadedRole);
        experienceRoleManagementService.setLevelToRole(experienceLevel, loadedRole);
    }

@@ -83,31 +115,54 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
     *             configuration
     */
    @Override
-    public CompletableFuture<Void> unsetRole(ARole role, Long feedbackChannelId) {
-        AChannel channel = channelManagementService.loadChannel(feedbackChannelId);
-        Optional<AExperienceRole> roleInServerOptional = experienceRoleManagementService.getRoleInServerOptional(role);
-        if(roleInServerOptional.isPresent()) {
-            AExperienceRole roleInServer = roleInServerOptional.get();
-            if(!roleInServer.getUsers().isEmpty()) {
-                log.info("Recalculating the roles for {} users, because their current role was removed from experience tracking.", roleInServer.getUsers().size());
-                List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(role.getServer());
-                roles.removeIf(role1 -> role1.getId().equals(roleInServer.getId()));
-                roles.sort(Comparator.comparing(innerRole -> innerRole.getLevel().getLevel()));
-                Long roleId = role.getId();
-                CompletableFutureList<RoleCalculationResult> calculationResults = userExperienceService.executeActionOnUserExperiencesWithFeedBack(roleInServer.getUsers(), channel,
-                        (AUserExperience ex) -> userExperienceService.updateUserRole(ex, roles, ex.getLevelOrDefault()));
-                return calculationResults.getMainFuture().thenAccept(aVoid ->
-                        self.persistData(calculationResults, roleId)
-                );
-            } else {
-                log.info("Roles does not have any active users, no need to remove them.");
-                experienceRoleManagementService.unsetRole(roleInServer);
-                return CompletableFuture.completedFuture(null);
-            }
-        } else {
-            log.info("Experience role is not define in server - skipping unset.");
+    public CompletableFuture<Void> unsetRoles(ARole role, Long feedbackChannelId) {
+        return unsetRoles(Arrays.asList(role), feedbackChannelId);
+    }
+
+    @Override
+    public List<AExperienceRole> getExperienceRolesAtLevel(Integer level, AServer server) {
+        AExperienceLevel levelObj = experienceLevelService.getLevel(level);
+        return experienceRoleManagementService.getExperienceRolesAtLevelInServer(levelObj, server);
+    }
+
+    @Override
+    public CompletableFuture<Void> unsetRoles(List<ARole> rolesToUnset, Long feedbackChannelId) {
+        return unsetRoles(rolesToUnset, feedbackChannelId, null);
+    }
+
+    @Override
+    public CompletableFuture<Void> unsetRoles(List<ARole> rolesToUnset, Long feedbackChannelId, AExperienceRole toAdd) {
+        if(rolesToUnset.isEmpty()) {
            return CompletableFuture.completedFuture(null);
        }
+        AServer server = rolesToUnset.get(0).getServer();
+        AChannel channel = channelManagementService.loadChannel(feedbackChannelId);
+        List<AExperienceRole> experienceRolesNecessaryToRemove = new ArrayList<>();
+        List<AUserExperience> usersToUpdate = new ArrayList<>();
+        rolesToUnset.forEach(role -> {
+            Optional<AExperienceRole> roleInServerOptional = experienceRoleManagementService.getRoleInServerOptional(role);
+            if(roleInServerOptional.isPresent()) {
+                AExperienceRole experienceRole = roleInServerOptional.get();
+                experienceRolesNecessaryToRemove.add(experienceRole);
+                usersToUpdate.addAll(experienceRole.getUsers());
+            } else {
+                log.info("Experience role {} is not defined in server {} - skipping unset.", role.getId(), server.getId());
+            }
+        });
+        log.info("Recalculating the roles for {} users, because their current role was removed from experience tracking.", usersToUpdate.size());
+        List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);
+        roles.removeIf(role1 -> experienceRolesNecessaryToRemove.stream().anyMatch(aExperienceRole -> aExperienceRole.getId().equals(role1.getId())));
+        if(toAdd != null) {
+            roles.add(toAdd);
+        }
+        roles.sort(Comparator.comparing(innerRole -> innerRole.getLevel().getLevel()));
+        List<Long> roleIds = experienceRolesNecessaryToRemove.stream().map(AExperienceRole::getId).collect(Collectors.toList());
+        if(toAdd != null) {
+            roleIds.removeIf(aLong -> aLong.equals(toAdd.getRole().getId()));
+        }
+        CompletableFutureList<RoleCalculationResult> calculationResults = userExperienceService.executeActionOnUserExperiencesWithFeedBack(usersToUpdate, channel,
+                (AUserExperience ex) -> userExperienceService.updateUserRole(ex, roles, ex.getLevelOrDefault()));
+        return calculationResults.getMainFuture().thenAccept(aVoid -> self.persistData(calculationResults, roleIds));
    }

    /**
@@ -116,13 +171,15 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
     * have to remove the existing {@link AExperienceRole experienceRole}
     * @param results A list of {@link CompletableFuture futures} which each contain a {@link RoleCalculationResult result}, for the members who got
     *                their {@link AExperienceRole experienceRole} removed
-     * @param roleId The ID of the {@link AExperienceRole experienceRole} which was removed from the experience roles
+     * @param roleIds The IDs of the {@link AExperienceRole experienceRoles} which were removed from the experience roles
     */
    @Transactional
-    public void persistData(CompletableFutureList<RoleCalculationResult> results, Long roleId) {
-        log.info("Persisting {} role calculation results after changing the role {}.", results.getFutures().size(), roleId);
-        AExperienceRole roleInServer = experienceRoleManagementService.getExperienceRoleById(roleId);
-        experienceRoleManagementService.unsetRole(roleInServer);
+    public void persistData(CompletableFutureList<RoleCalculationResult> results, List<Long> roleIds) {
+        log.info("Persisting {} role calculation results.", results.getFutures().size());
+        roleIds.forEach(roleId -> {
+            log.info("Deleting experience role {}.", roleId);
+            deleteExperienceRoleViaId(roleId);
+        });
        userExperienceService.syncRolesInStorage(results.getObjects());
    }

@@ -153,4 +210,21 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
        return aExperienceRole != null ? aExperienceRole.getLevel() : AExperienceLevel.builder().level(200).build();
    }

+    @Override
+    public List<LevelRole> loadLevelRoleConfigForServer(AServer server) {
+        List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);
+        List<LevelRole> levelRoles = new ArrayList<>();
+        roles.forEach(aExperienceRole -> {
+            Role role = roleService.getRoleFromGuild(aExperienceRole.getRole());
+            LevelRole levelRole = LevelRole
+                    .builder()
+                    .role(role)
+                    .roleId(aExperienceRole.getId())
+                    .level(aExperienceRole.getLevel().getLevel())
+                    .build();
+            levelRoles.add(levelRole);
+        });
+        return levelRoles;
+    }
+
 }
--- a/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/management/ExperienceLevelManagementServiceBean.java
+++ b/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/management/ExperienceLevelManagementServiceBean.java
@@ -1,5 +1,6 @@
 package dev.sheldan.abstracto.experience.service.management;

+import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
 import dev.sheldan.abstracto.experience.model.database.AExperienceLevel;
 import dev.sheldan.abstracto.experience.repository.ExperienceLevelRepository;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -9,7 +10,7 @@ import java.util.List;
 import java.util.Optional;

@Component
-public class    ExperienceLevelManagementServiceBean implements ExperienceLevelManagementService {
+public class ExperienceLevelManagementServiceBean implements ExperienceLevelManagementService {

    @Autowired
    private ExperienceLevelRepository experienceLevelRepository;
@@ -30,10 +31,15 @@ public class    ExperienceLevelManagementServiceBean implements ExperienceLevelM
    }

    @Override
-    public Optional<AExperienceLevel> getLevel(Integer level) {
+    public Optional<AExperienceLevel> getLevelOptional(Integer level) {
        return experienceLevelRepository.findById(level);
    }

+    @Override
+    public AExperienceLevel getLevel(Integer level) {
+        return getLevelOptional(level).orElseThrow(() -> new AbstractoRunTimeException("Level not found."));
+    }
+
    @Override
    public List<AExperienceLevel> getLevelConfig() {
        return experienceLevelRepository.findAll();
--- a/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/management/ExperienceRoleManagementServiceBean.java
+++ b/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/management/ExperienceRoleManagementServiceBean.java
@@ -30,10 +30,14 @@ public class ExperienceRoleManagementServiceBean implements ExperienceRoleManage
     * @param server The server in which this should happen
     */
    @Override
-    public void removeAllRoleAssignmentsForLevelInServer(AExperienceLevel level, AServer server) {
+    public void removeAllRoleAssignmentsForLevelInServerExceptRole(AExperienceLevel level, AServer server, ARole role) {
        List<AExperienceRole> existingExperienceRoles = experienceRoleRepository.findByLevelAndRoleServer(level, server);
        log.info("Removing all role assignments ({}) for level {} in server {}.", existingExperienceRoles.size(), level.getLevel(), server.getId());
-        existingExperienceRoles.forEach(existingRole -> experienceRoleRepository.delete(existingRole));
+        existingExperienceRoles.forEach(existingRole -> {
+            if(!existingRole.getRole().getId().equals(role.getId())) {
+                experienceRoleRepository.delete(existingRole);
+            }
+        });
    }

    @Override
@@ -97,4 +101,9 @@ public class ExperienceRoleManagementServiceBean implements ExperienceRoleManage
        }
        return experienceRole;
    }
+
+    @Override
+    public List<AExperienceRole> getExperienceRolesAtLevelInServer(AExperienceLevel level, AServer server) {
+        return experienceRoleRepository.findByLevelAndRoleServer(level, server);
+    }
 }
--- a/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/management/UserExperienceManagementServiceBean.java
+++ b/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/management/UserExperienceManagementServiceBean.java
@@ -45,7 +45,7 @@ public class UserExperienceManagementServiceBean implements UserExperienceManage
    @Override
    public AUserExperience createUserInServer(AUserInAServer aUserInAServer) {
        log.info("Creating user experience for user {} in server {}.", aUserInAServer.getUserReference().getId(),aUserInAServer.getServerReference().getId());
-        AExperienceLevel startingLevel = experienceLevelManagementService.getLevel(0).orElseThrow(() -> new AbstractoRunTimeException(String.format("Could not find level %s", 0)));
+        AExperienceLevel startingLevel = experienceLevelManagementService.getLevelOptional(0).orElseThrow(() -> new AbstractoRunTimeException(String.format("Could not find level %s", 0)));
        return AUserExperience
                .builder()
                .experience(0L)
--- a/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/resources/migrations/1.0-experience/experience-seedData/command.xml
+++ b/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/resources/migrations/1.0-experience/experience-seedData/command.xml
@@ -64,6 +64,11 @@
            <column name="module_id" valueComputed="${experienceModule}"/>
            <column name="feature_id" valueComputed="${experienceFeature}"/>
        </insert>
+        <insert tableName="command">
+            <column name="name" value="levelRoles"/>
+            <column name="module_id" valueComputed="${experienceModule}"/>
+            <column name="feature_id" valueComputed="${experienceFeature}"/>
+        </insert>
    </changeSet>

 </databaseChangeLog>