[maven-release-plugin] prepare release v1.5.9

removing custom cooldown handling from payday and slots commands

.github/workflows/build.yml

@@ -1,7 +1,7 @@
 # This workflow will build a Java project with Maven
 # For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven
 
-name: Execute build and Sonar
+name: Execute Build
 
 on:
   push:
@@ -19,26 +19,14 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
-    - name: Set up JDK 1.8
-      uses: actions/setup-java@v1
+    - uses: actions/checkout@v3
+    - name: Set up JDK 17
+      uses: actions/setup-java@v3
       with:
-        java-version: 1.8
+        distribution: 'corretto'
+        java-version: 17
     - name: Build with Maven
       run: mvn -B install --file abstracto-application/pom.xml
-    - name: Setup sonarqube
-      uses: warchant/setup-sonar-scanner@v3
-    - name: Run sonarqube
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      run: sonar-scanner
-       -Dsonar.login=${{ secrets.SONAR_TOKEN }}
-       -Dsonar.organization=sheldan
-       -Dsonar.host.url=https://sonarcloud.io/
-       -Dsonar.projectKey=abstracto-core
-       -Dsonar.java.binaries=**/target/classes
-       -Dsonar.coverage.jacoco.xmlReportPaths=abstracto-application/coverage/target/site/jacoco-aggregate/jacoco.xml
-       -Dsonar.coverage.exclusions=**/*Test.java
     - uses: actions/setup-ruby@v1
     - name: Send Webhook Notification
       if: always()

.github/workflows/release.yml

@@ -6,13 +6,14 @@ jobs:
   publish:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           persist-credentials: false
       - name: Set up Java for publishing to GitHub Packages
-        uses: actions/setup-java@v1
+        uses: actions/setup-java@v3
         with:
-          java-version: 1.8
+          distribution: 'corretto'
+          java-version: 17
       - name: Load current version
         id: version
         run: echo "version=$(mvn --file abstracto-application/pom.xml -q -Dexec.executable="echo" -Dexec.args='${project.version}' --non-recursive exec:exec)" >> $GITHUB_ENV
@@ -21,7 +22,7 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       - name: Deploy documentation to GitHub pages
-        uses: JamesIves/github-pages-deploy-action@4.1.0
+        uses: JamesIves/github-pages-deploy-action@v4
         with:
           repository-name: Sheldan/abstracto-docs
           target-folder: docs/${{ env.version }}
@@ -29,22 +30,27 @@ jobs:
           ssh-key: ${{ secrets.ACTIONS_DEPLOY_KEY }}
           folder: abstracto-application/documentation/target/generated-docs
       - name: Deploy documentation to GitHub pages latest
-        uses: JamesIves/github-pages-deploy-action@4.1.0
+        uses: JamesIves/github-pages-deploy-action@v4
         with:
           repository-name: Sheldan/abstracto-docs
           target-folder: docs/current
           branch: master
           ssh-key: ${{ secrets.ACTIONS_DEPLOY_KEY }}
           folder: abstracto-application/documentation/target/generated-docs
-      - name: Login to GitHub Packages Docker Registry
-        uses: docker/login-action@v1
+      - name: Login to Harbor
+        uses: docker/login-action@v2
         with:
-          registry: docker.pkg.github.com
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Push deployment container
-        working-directory: ./abstracto-application/installer/src/main/docker/deployment
+          registry: harbor.sheldan.dev
+          username: ${{ secrets.HARBOR_USERNAME }}
+          password: ${{ secrets.HARBOR_TOKEN }}
+      - name: Load env files
+        id: dotenv
+        uses: falti/dotenv-action@v1.0.4
+        with:
+          path: ./deployment/installer/.env
+      - name: Push container
         run: docker-compose build && docker-compose push
+        working-directory: ./deployment/installer/
         env:
-          REGISTRY_PREFIX: docker.pkg.github.com/sheldan/abstracto/
-          VERSION: ${{ env.version }}
+          REGISTRY_PREFIX: ${{ steps.dotenv.outputs.registry_prefix }}
+          VERSION: ${{ steps.dotenv.outputs.version }}

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Sheldan
+Copyright (c) 2023 Sheldan
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,8 +1,6 @@
 # Abstracto
 
-![Build](https://github.com/Sheldan/abstracto/workflows/Execute%20build%20and%20Sonar/badge.svg)
-[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=abstracto-core&metric=coverage)](https://sonarcloud.io/dashboard?id=abstracto-core)
-[![SonarCloud](https://sonarcloud.io/images/project_badges/sonarcloud-white.svg)](https://sonarcloud.io/dashboard?id=abstracto-core)
+![Build](https://github.com/Sheldan/abstracto/workflows/Execute%20Build/badge.svg)
 [![GitHub license](https://img.shields.io/github/license/Sheldan/abstracto)](https://github.com/Sheldan/abstracto/blob/master/LICENSE)
 
 
@@ -14,22 +12,20 @@ An example implementation of this bot can be seen [here](https://github.com/Shel
 
 
 ## Technologies
-* [JDA](https://github.com/DV8FromTheWorld/JDA/) The Discord API Wrapper in the version 5.0.0-alpha.21
-* [Spring boot](https://github.com/spring-projects/spring-boot) is used as a framework to create standalone application in Java with Java EE methods. (including Dependency injection and more)
+* [JDA](https://github.com/DV8FromTheWorld/JDA/) The Discord API Wrapper in the version 5.0.0-beta.5
+* [Spring boot](https://github.com/spring-projects/spring-boot) is used as a framework to create standalone application in Java with Java EE methods. (including dependency injection and more)
 * [Hibernate](https://github.com/hibernate/hibernate-orm) is used as a reference implementation of JPA.
 * [Freemarker](https://github.com/apache/freemarker) is used as a templating engine. This is used to provide internationalization for user facing text and enable dynamic embed configuration.
 * [Ehcache](https://github.com/ehcache/ehcache3) is used as a caching implementation.
 * [Lombok](https://github.com/rzwitserloot/lombok) is used as a framework in order to speed up creation of container classes and builders.
-* [Quartz](https://github.com/quartz-scheduler/quartz) is used as a scheduling framework in order to provide functionalities which either require a delayed or cronjob behaviour.
-* [Docker](https://github.com/docker) is used to package the application into a container and [Docker Compose](https://github.com/docker/compose) is used to connect the required containers together.
+* [Quartz](https://github.com/quartz-scheduler/quartz) is used as a scheduling framework in order to provide functionalities which either require a scheduled or cronjob behaviour.
+* [Docker](https://github.com/docker) is used to package the application into an image and [Docker Compose](https://github.com/docker/compose) is used to build the images
 * [Liquibase](https://github.com/liquibase/liquibase) is used to manage changes to the database
 
 ## Documentation
 A detailed documentation of the pure form of Abstracto including the terminology and commands in HTML form is available [here](https://sheldan.github.io/abstracto-docs/current). The PDF is available [here](https://sheldan.github.io/abstracto-docs/current/documentation.pdf)
 If you want to view the documentation to an earlier released version you need to append the desired version to the URL. The current version will be available aforementioned URL, but it is not right now, because Abstracto has not been released yet.
 
-## Customization documentation 
-TBD when Abstracto is released, as the current version is still being adapted, because of findings from the example customization in Crimson.
 
 ## Issues
 If you find any issue, feel free to create a GitHub issue.

abstracto-application/abstracto-modules/anti-raid/anti-raid-impl/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>anti-raid</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.4.5</version>
+        <version>1.5.9</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/anti-raid/anti-raid-int/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>anti-raid</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.4.5</version>
+        <version>1.5.9</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/anti-raid/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>abstracto-modules</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.4.5</version>
+        <version>1.5.9</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>assignable-roles</artifactId>
-        <version>1.4.5</version>
+        <version>1.5.9</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-int/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>assignable-roles</artifactId>
-        <version>1.4.5</version>
+        <version>1.5.9</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
     <artifactId>assignable-roles-int</artifactId>

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-int/src/main/java/dev/sheldan/abstracto/assignableroles/exception/AssignableRoleAlreadyDefinedException.java

@@ -9,7 +9,7 @@ import net.dv8tion.jda.api.entities.Role;
 /**
  * Exception thrown in case the {@link dev.sheldan.abstracto.assignableroles.model.database.AssignableRole} has already been
  * defined for an {@link dev.sheldan.abstracto.assignableroles.model.database.AssignableRolePlace}. This is identified
- * via the {@link net.dv8tion.jda.api.entities.Emote} which is used to react.
+ * via the emote which is used to react.
  */
 public class AssignableRoleAlreadyDefinedException extends AbstractoRunTimeException implements Templatable {
     private final AssignableRoleAlreadyDefinedExceptionModel model;

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-int/src/main/java/dev/sheldan/abstracto/assignableroles/exception/AssignableRolePlaceAlreadyExistsException.java

@@ -6,7 +6,7 @@ import dev.sheldan.abstracto.core.templating.Templatable;
 
 /**
  * Exception thrown in case the {@link dev.sheldan.abstracto.assignableroles.model.database.AssignableRolePlace place}
- * identified by {@link dev.sheldan.abstracto.assignableroles.model.database.AssignableRolePlace#key}
+ * identified by {@link dev.sheldan.abstracto.assignableroles.model.database.AssignableRolePlace} key
  */
 public class AssignableRolePlaceAlreadyExistsException extends AbstractoRunTimeException implements Templatable {
 

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-int/src/main/java/dev/sheldan/abstracto/assignableroles/model/database/AssignableRole.java

@@ -6,7 +6,7 @@ import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.ComponentPayload;
 import lombok.*;
 
-import javax.persistence.*;
+import jakarta.persistence.*;
 import java.io.Serializable;
 import java.time.Instant;
 import java.util.ArrayList;

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-int/src/main/java/dev/sheldan/abstracto/assignableroles/model/database/AssignableRoleCondition.java

@@ -3,7 +3,7 @@ package dev.sheldan.abstracto.assignableroles.model.database;
 import dev.sheldan.abstracto.assignableroles.model.condition.AssignableRoleConditionType;
 import lombok.*;
 
-import javax.persistence.*;
+import jakarta.persistence.*;
 
 @Entity
 @Table(name = "assignable_role_condition")

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-int/src/main/java/dev/sheldan/abstracto/assignableroles/model/database/AssignableRolePlace.java

@@ -4,7 +4,7 @@ import dev.sheldan.abstracto.core.models.database.AChannel;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import lombok.*;
 
-import javax.persistence.*;
+import jakarta.persistence.*;
 import java.io.Serializable;
 import java.time.Instant;
 import java.util.ArrayList;

abstracto-application/abstracto-modules/assignable-roles/assignable-roles-int/src/main/java/dev/sheldan/abstracto/assignableroles/model/database/AssignedRoleUser.java

@@ -3,7 +3,7 @@ package dev.sheldan.abstracto.assignableroles.model.database;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import lombok.*;
 
-import javax.persistence.*;
+import jakarta.persistence.*;
 import java.io.Serializable;
 import java.time.Instant;
 import java.util.ArrayList;

abstracto-application/abstracto-modules/assignable-roles/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>abstracto-modules</artifactId>
-        <version>1.4.5</version>
+        <version>1.5.9</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/custom-command/custom-command-impl/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>custom-command</artifactId>
-        <version>1.4.5</version>
+        <version>1.5.9</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/java/dev/sheldan/abstracto/customcommand/command/CreateCustomCommand.java

@@ -0,0 +1,99 @@
+package dev.sheldan.abstracto.customcommand.command;
+
+import dev.sheldan.abstracto.core.command.UtilityModuleDefinition;
+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.CommandResult;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+import dev.sheldan.abstracto.customcommand.config.CustomCommandFeatureDefinition;
+import dev.sheldan.abstracto.customcommand.config.CustomCommandSlashCommandNames;
+import dev.sheldan.abstracto.customcommand.service.management.CustomCommandService;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+@Slf4j
+public class CreateCustomCommand extends AbstractConditionableCommand {
+
+    private static final String CREATE_CUSTOM_COMMAND_COMMAND = "createCustomCommand";
+    private static final String CUSTOM_COMMAND_NAME_PARAMETER = "commandName";
+    private static final String CUSTOM_COMMAND_CONTENT_PARAMETER = "response";
+    private static final String CREATE_CUSTOM_COMMAND_RESPONSE_TEMPLATE_KEY = "createCustomCommand_response";
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private CustomCommandService customCommandService;
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String name = slashCommandParameterService.getCommandOption(CUSTOM_COMMAND_NAME_PARAMETER, event, String.class);
+        String content = slashCommandParameterService.getCommandOption(CUSTOM_COMMAND_CONTENT_PARAMETER, event, String.class);
+
+        customCommandService.createCustomCommand(name, content, event.getMember());
+        return interactionService.replyEmbed(CREATE_CUSTOM_COMMAND_RESPONSE_TEMPLATE_KEY, event)
+                .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return CustomCommandFeatureDefinition.CUSTOM_COMMAND;
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        Parameter commandNameParameter = Parameter
+                .builder()
+                .name(CUSTOM_COMMAND_NAME_PARAMETER)
+                .templated(true)
+                .type(String.class)
+                .build();
+
+        Parameter commandContentParameter = Parameter
+                .builder()
+                .name(CUSTOM_COMMAND_CONTENT_PARAMETER)
+                .templated(true)
+                .type(String.class)
+                .build();
+
+        List<Parameter> parameters = Arrays.asList(commandNameParameter, commandContentParameter);
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(CustomCommandSlashCommandNames.CUSTOM_COMMAND)
+                .commandName("create")
+                .build();
+
+        return CommandConfiguration.builder()
+                .name(CREATE_CUSTOM_COMMAND_COMMAND)
+                .module(UtilityModuleDefinition.UTILITY)
+                .templated(true)
+                .async(true)
+                .slashCommandConfig(slashCommandConfig)
+                .causesReaction(true)
+                .supportsEmbedException(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+}

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/java/dev/sheldan/abstracto/customcommand/command/DeleteCustomCommand.java

@@ -0,0 +1,90 @@
+package dev.sheldan.abstracto.customcommand.command;
+
+import dev.sheldan.abstracto.core.command.UtilityModuleDefinition;
+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.CommandResult;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+import dev.sheldan.abstracto.customcommand.config.CustomCommandFeatureDefinition;
+import dev.sheldan.abstracto.customcommand.config.CustomCommandSlashCommandNames;
+import dev.sheldan.abstracto.customcommand.service.management.CustomCommandService;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+@Slf4j
+public class DeleteCustomCommand extends AbstractConditionableCommand {
+
+    private static final String DELETE_CUSTOM_COMMAND_COMMAND = "deleteCustomCommand";
+    private static final String DELETE_CUSTOM_COMMAND_RESPONSE_TEMPLATE_KEY = "deleteCustomCommand_response";
+    private static final String CUSTOM_COMMAND_NAME_PARAMETER = "commandName";
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private CustomCommandService customCommandService;
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String name = slashCommandParameterService.getCommandOption(CUSTOM_COMMAND_NAME_PARAMETER, event, String.class);
+
+        customCommandService.deleteCustomCommand(name, event.getGuild());
+        return interactionService.replyEmbed(DELETE_CUSTOM_COMMAND_RESPONSE_TEMPLATE_KEY, event)
+                .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return CustomCommandFeatureDefinition.CUSTOM_COMMAND;
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        Parameter commandNameParameter = Parameter
+                .builder()
+                .name(CUSTOM_COMMAND_NAME_PARAMETER)
+                .templated(true)
+                .type(String.class)
+                .build();
+
+        List<Parameter> parameters = Arrays.asList(commandNameParameter);
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(CustomCommandSlashCommandNames.CUSTOM_COMMAND)
+                .commandName("delete")
+                .build();
+
+        return CommandConfiguration.builder()
+                .name(DELETE_CUSTOM_COMMAND_COMMAND)
+                .module(UtilityModuleDefinition.UTILITY)
+                .templated(true)
+                .async(true)
+                .slashCommandConfig(slashCommandConfig)
+                .causesReaction(true)
+                .supportsEmbedException(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+}

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/java/dev/sheldan/abstracto/customcommand/command/GetCustomCommand.java

@@ -0,0 +1,113 @@
+package dev.sheldan.abstracto.customcommand.command;
+
+import dev.sheldan.abstracto.core.command.UtilityModuleDefinition;
+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.CommandResult;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandAutoCompleteService;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+import dev.sheldan.abstracto.customcommand.config.CustomCommandFeatureDefinition;
+import dev.sheldan.abstracto.customcommand.config.CustomCommandSlashCommandNames;
+import dev.sheldan.abstracto.customcommand.model.command.CustomCommandResponseModel;
+import dev.sheldan.abstracto.customcommand.model.database.CustomCommand;
+import dev.sheldan.abstracto.customcommand.service.management.CustomCommandService;
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+public class GetCustomCommand extends AbstractConditionableCommand {
+
+    private static final String GET_CUSTOM_COMMAND_COMMAND = "getCustomCommand";
+    private static final String CUSTOM_COMMAND_NAME_PARAMETER = "commandName";
+    private static final String GET_CUSTOM_COMMAND_RESPONSE_TEMPLATE_KEY = "getCustomCommand_response";
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private CustomCommandService customCommandService;
+
+    @Autowired
+    private SlashCommandAutoCompleteService slashCommandAutoCompleteService;
+
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        String name = slashCommandParameterService.getCommandOption(CUSTOM_COMMAND_NAME_PARAMETER, event, String.class);
+        CustomCommand customCommand = customCommandService.getCustomCommand(name, event.getGuild());
+        CustomCommandResponseModel model = CustomCommandResponseModel
+                .builder()
+                .additionalText(customCommand.getAdditionalMessage())
+                .build();
+        return interactionService.replyEmbed(GET_CUSTOM_COMMAND_RESPONSE_TEMPLATE_KEY, model, event)
+                .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public List<String> performAutoComplete(CommandAutoCompleteInteractionEvent event) {
+        if(slashCommandAutoCompleteService.matchesParameter(event.getFocusedOption(), CUSTOM_COMMAND_NAME_PARAMETER)) {
+            String input = event.getFocusedOption().getValue();
+            return customCommandService.getCustomCommandsStartingWith(input, event.getGuild())
+                    .stream()
+                    .map(CustomCommand::getName)
+                    .toList();
+        } else {
+            return new ArrayList<>();
+        }
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return CustomCommandFeatureDefinition.CUSTOM_COMMAND;
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        Parameter commandNameParameter = Parameter
+                .builder()
+                .name(CUSTOM_COMMAND_NAME_PARAMETER)
+                .templated(true)
+                .supportsAutoComplete(true)
+                .type(String.class)
+                .build();
+
+        List<Parameter> parameters = Arrays.asList(commandNameParameter);
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(CustomCommandSlashCommandNames.CUSTOM_COMMAND_PUBLIC)
+                .commandName("get")
+                .build();
+
+        return CommandConfiguration.builder()
+                .name(GET_CUSTOM_COMMAND_COMMAND)
+                .module(UtilityModuleDefinition.UTILITY)
+                .templated(true)
+                .async(true)
+                .slashCommandConfig(slashCommandConfig)
+                .causesReaction(true)
+                .supportsEmbedException(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+}

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/java/dev/sheldan/abstracto/customcommand/command/ListCustomCommands.java

@@ -0,0 +1,85 @@
+package dev.sheldan.abstracto.customcommand.command;
+
+import dev.sheldan.abstracto.core.command.UtilityModuleDefinition;
+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.execution.CommandResult;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.service.PaginatorService;
+import dev.sheldan.abstracto.customcommand.config.CustomCommandFeatureDefinition;
+import dev.sheldan.abstracto.customcommand.config.CustomCommandSlashCommandNames;
+import dev.sheldan.abstracto.customcommand.model.command.ListCustomCommandsResponseModel;
+import dev.sheldan.abstracto.customcommand.model.database.CustomCommand;
+import dev.sheldan.abstracto.customcommand.service.management.CustomCommandService;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+@Slf4j
+public class ListCustomCommands extends AbstractConditionableCommand {
+
+    private static final String CREATE_CUSTOM_COMMAND_COMMAND = "listCustomCommands";
+    private static final String LIST_CUSTOM_COMMANDS_TEMPLATE_KEY = "listCustomCommands_response";
+    private static final String NO_CUSTOM_COMMANDS_TEMPLATE_KEY = "listCustomCommands_no_commands_response";
+
+    @Autowired
+    private CustomCommandService customCommandService;
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private PaginatorService paginatorService;
+
+
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        List<CustomCommand> customCommands = customCommandService.getCustomCommands(event.getGuild());
+        if(customCommands.isEmpty()) {
+            return interactionService.replyEmbed(NO_CUSTOM_COMMANDS_TEMPLATE_KEY, event)
+                    .thenApply(interactionHook -> CommandResult.fromSuccess());
+        }
+        ListCustomCommandsResponseModel model = ListCustomCommandsResponseModel.fromCommands(customCommands);
+        return paginatorService.createPaginatorFromTemplate(LIST_CUSTOM_COMMANDS_TEMPLATE_KEY, model, event)
+                .thenApply(unused -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return CustomCommandFeatureDefinition.CUSTOM_COMMAND;
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(CustomCommandSlashCommandNames.CUSTOM_COMMAND_PUBLIC)
+                .commandName("list")
+                .build();
+
+        return CommandConfiguration.builder()
+                .name(CREATE_CUSTOM_COMMAND_COMMAND)
+                .module(UtilityModuleDefinition.UTILITY)
+                .templated(true)
+                .async(true)
+                .slashCommandConfig(slashCommandConfig)
+                .causesReaction(true)
+                .supportsEmbedException(true)
+                .help(helpInfo)
+                .build();
+    }
+}

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/java/dev/sheldan/abstracto/customcommand/repository/CustomCommandRepository.java

@@ -5,9 +5,13 @@ import dev.sheldan.abstracto.customcommand.model.database.CustomCommand;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
+import java.util.List;
 import java.util.Optional;
 
 @Repository
 public interface CustomCommandRepository extends JpaRepository<CustomCommand, Long> {
     Optional<CustomCommand> getByNameIgnoreCaseAndServer(String name, AServer server);
+    void deleteByNameAndServer(String name, AServer server);
+    List<CustomCommand> findByServer(AServer server);
+    List<CustomCommand> findByNameStartsWithIgnoreCaseAndServer(String prefix, AServer server);
 }

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/java/dev/sheldan/abstracto/customcommand/service/CustomCommandServiceBean.java

@@ -0,0 +1,66 @@
+package dev.sheldan.abstracto.customcommand.service;
+
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
+import dev.sheldan.abstracto.customcommand.exception.CustomCommandExistsException;
+import dev.sheldan.abstracto.customcommand.exception.CustomCommandNotFoundException;
+import dev.sheldan.abstracto.customcommand.model.database.CustomCommand;
+import dev.sheldan.abstracto.customcommand.service.management.CustomCommandManagementService;
+import dev.sheldan.abstracto.customcommand.service.management.CustomCommandService;
+import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.Member;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+public class CustomCommandServiceBean implements CustomCommandService {
+
+    @Autowired
+    private UserInServerManagementService userInServerManagementService;
+
+    @Autowired
+    private CustomCommandManagementService customCommandManagementService;
+
+    @Autowired
+    private ServerManagementService serverManagementService;
+
+    @Override
+    public CustomCommand createCustomCommand(String name, String content, Member creator) {
+        if(customCommandManagementService.getCustomCommandByName(name, creator.getGuild().getIdLong()).isPresent()) {
+            throw new CustomCommandExistsException();
+        }
+        AUserInAServer creatorUser = userInServerManagementService.loadOrCreateUser(creator);
+        return customCommandManagementService.createCustomCommand(name, content, creatorUser);
+    }
+
+    @Override
+    public void deleteCustomCommand(String name, Guild guild) {
+        if(customCommandManagementService.getCustomCommandByName(name, guild.getIdLong()).isEmpty()) {
+            throw new CustomCommandNotFoundException();
+        }
+        AServer server = serverManagementService.loadServer(guild);
+        customCommandManagementService.deleteCustomCommand(name, server);
+    }
+
+    @Override
+    public List<CustomCommand> getCustomCommands(Guild guild) {
+        AServer server = serverManagementService.loadServer(guild);
+        return customCommandManagementService.getCustomCommands(server);
+    }
+
+    @Override
+    public CustomCommand getCustomCommand(String name, Guild guild) {
+        return customCommandManagementService.getCustomCommandByName(name, guild.getIdLong())
+                .orElseThrow(CustomCommandNotFoundException::new);
+    }
+
+    @Override
+    public List<CustomCommand> getCustomCommandsStartingWith(String prefix, Guild guild) {
+        AServer server = serverManagementService.loadServer(guild);
+        return customCommandManagementService.getCustomCommandsStartingWith(prefix, server);
+    }
+}

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/java/dev/sheldan/abstracto/customcommand/service/management/CustomCommandManagementServiceBean.java

@@ -1,12 +1,14 @@
 package dev.sheldan.abstracto.customcommand.service.management;
 
 import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.management.ServerManagementService;
 import dev.sheldan.abstracto.customcommand.model.database.CustomCommand;
 import dev.sheldan.abstracto.customcommand.repository.CustomCommandRepository;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
+import java.util.List;
 import java.util.Optional;
 
 @Component
@@ -23,4 +25,32 @@ public class CustomCommandManagementServiceBean implements CustomCommandManageme
         AServer server = serverManagementService.loadServer(serverId);
         return repository.getByNameIgnoreCaseAndServer(name, server);
     }
+
+    @Override
+    public CustomCommand createCustomCommand(String name, String content, AUserInAServer creator) {
+        CustomCommand customCommand = CustomCommand
+                .builder()
+                .name(name)
+                .additionalMessage(content)
+                .server(creator.getServerReference())
+                .creator(creator)
+                .build();
+        return repository.save(customCommand);
+    }
+
+    @Override
+    public void deleteCustomCommand(String name, AServer server) {
+        repository.deleteByNameAndServer(name, server);
+    }
+
+    @Override
+    public List<CustomCommand> getCustomCommands(AServer server) {
+        return repository.findByServer(server);
+    }
+
+    @Override
+    public List<CustomCommand> getCustomCommandsStartingWith(String prefix, AServer server) {
+        return repository.findByNameStartsWithIgnoreCaseAndServer(prefix, server);
+    }
+
 }

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/resources/migrations/1.5.8/collection.xml

@@ -0,0 +1,11 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
+    <include file="seedData/data.xml" relativeToChangelogFile="true"/>
+    <include file="tables/tables.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/resources/migrations/1.5.8/seedData/command.xml

@@ -0,0 +1,35 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
+    <property name="utilityModule" value="(SELECT id FROM module WHERE name = 'utility')"/>
+    <property name="customCommandFeature" value="(SELECT id FROM feature WHERE key = 'customCommand')"/>
+
+    <changeSet  author="Sheldan"  id="customCommand-commands">
+        <insert tableName="command">
+            <column name="name" value="createCustomCommand"/>
+            <column name="module_id" valueComputed="${utilityModule}"/>
+            <column name="feature_id" valueComputed="${customCommandFeature}"/>
+        </insert>
+        <insert tableName="command">
+            <column name="name" value="deleteCustomCommand"/>
+            <column name="module_id" valueComputed="${utilityModule}"/>
+            <column name="feature_id" valueComputed="${customCommandFeature}"/>
+        </insert>
+        <insert tableName="command">
+            <column name="name" value="getCustomCommand"/>
+            <column name="module_id" valueComputed="${utilityModule}"/>
+            <column name="feature_id" valueComputed="${customCommandFeature}"/>
+        </insert>
+        <insert tableName="command">
+            <column name="name" value="listCustomCommands"/>
+            <column name="module_id" valueComputed="${utilityModule}"/>
+            <column name="feature_id" valueComputed="${customCommandFeature}"/>
+        </insert>
+    </changeSet>
+
+</databaseChangeLog>

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/resources/migrations/1.5.8/seedData/data.xml

@@ -0,0 +1,10 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
+    <include file="command.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/resources/migrations/1.5.8/tables/custom_command.xml

@@ -0,0 +1,16 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
+    <changeSet author="Sheldan" id="custom_command-add_auto_increment">
+        <sql>
+            create sequence custom_command_id_seq;
+            alter table custom_command alter id set default nextval('custom_command_id_seq');
+        </sql>
+    </changeSet>
+
+</databaseChangeLog>

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/resources/migrations/1.5.8/tables/tables.xml

@@ -0,0 +1,10 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
+    <include file="custom_command.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/abstracto-modules/custom-command/custom-command-impl/src/main/resources/migrations/custom-command-changeLog.xml

@@ -7,4 +7,5 @@
     http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
     http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
     <include file="1.4.0/collection.xml" relativeToChangelogFile="true"/>
+    <include file="1.5.8/collection.xml" relativeToChangelogFile="true"/>
 </databaseChangeLog>

abstracto-application/abstracto-modules/custom-command/custom-command-int/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>custom-command</artifactId>
-        <version>1.4.5</version>
+        <version>1.5.9</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/custom-command/custom-command-int/src/main/java/dev/sheldan/abstracto/customcommand/config/CustomCommandSlashCommandNames.java

@@ -0,0 +1,6 @@
+package dev.sheldan.abstracto.customcommand.config;
+
+public class CustomCommandSlashCommandNames {
+    public static final String CUSTOM_COMMAND = "cc";
+    public static final String CUSTOM_COMMAND_PUBLIC = "customCommands";
+}

abstracto-application/abstracto-modules/custom-command/custom-command-int/src/main/java/dev/sheldan/abstracto/customcommand/exception/CustomCommandExistsException.java

@@ -0,0 +1,15 @@
+package dev.sheldan.abstracto.customcommand.exception;
+
+import dev.sheldan.abstracto.core.exception.AbstractoTemplatableException;
+
+public class CustomCommandExistsException extends AbstractoTemplatableException {
+    @Override
+    public String getTemplateName() {
+        return "custom_command_exists_exception";
+    }
+
+    @Override
+    public Object getTemplateModel() {
+        return new Object();
+    }
+}

abstracto-application/abstracto-modules/custom-command/custom-command-int/src/main/java/dev/sheldan/abstracto/customcommand/exception/CustomCommandNotFoundException.java

@@ -0,0 +1,15 @@
+package dev.sheldan.abstracto.customcommand.exception;
+
+import dev.sheldan.abstracto.core.exception.AbstractoTemplatableException;
+
+public class CustomCommandNotFoundException extends AbstractoTemplatableException {
+    @Override
+    public String getTemplateName() {
+        return "custom_command_not_found_exception";
+    }
+
+    @Override
+    public Object getTemplateModel() {
+        return new Object();
+    }
+}

abstracto-application/abstracto-modules/custom-command/custom-command-int/src/main/java/dev/sheldan/abstracto/customcommand/model/command/ListCustomCommandModel.java

@@ -0,0 +1,23 @@
+package dev.sheldan.abstracto.customcommand.model.command;
+
+import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
+import dev.sheldan.abstracto.customcommand.model.database.CustomCommand;
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder
+public class ListCustomCommandModel {
+    private String name;
+    private String content;
+    private MemberDisplay creator;
+
+    public static ListCustomCommandModel fromCustomCommand(CustomCommand customCommand) {
+        return ListCustomCommandModel
+                .builder()
+                .name(customCommand.getName())
+                .content(customCommand.getAdditionalMessage())
+                .creator(MemberDisplay.fromAUserInAServer(customCommand.getCreator()))
+                .build();
+    }
+}

abstracto-application/abstracto-modules/custom-command/custom-command-int/src/main/java/dev/sheldan/abstracto/customcommand/model/command/ListCustomCommandsResponseModel.java

@@ -0,0 +1,24 @@
+package dev.sheldan.abstracto.customcommand.model.command;
+
+import dev.sheldan.abstracto.customcommand.model.database.CustomCommand;
+import lombok.Builder;
+import lombok.Getter;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Builder
+@Getter
+public class ListCustomCommandsResponseModel {
+    private List<ListCustomCommandModel> customCommands;
+
+    public static ListCustomCommandsResponseModel fromCommands(List<CustomCommand> customCommands) {
+        return ListCustomCommandsResponseModel
+                .builder()
+                .customCommands(customCommands
+                        .stream()
+                        .map(ListCustomCommandModel::fromCustomCommand)
+                        .collect(Collectors.toList()))
+                .build();
+    }
+}

abstracto-application/abstracto-modules/custom-command/custom-command-int/src/main/java/dev/sheldan/abstracto/customcommand/model/database/CustomCommand.java

@@ -3,7 +3,7 @@ package dev.sheldan.abstracto.customcommand.model.database;
 import dev.sheldan.abstracto.core.models.database.*;
 import lombok.*;
 
-import javax.persistence.*;
+import jakarta.persistence.*;
 import java.io.Serializable;
 import java.time.Instant;
 

abstracto-application/abstracto-modules/custom-command/custom-command-int/src/main/java/dev/sheldan/abstracto/customcommand/service/management/CustomCommandManagementService.java

@@ -1,9 +1,16 @@
 package dev.sheldan.abstracto.customcommand.service.management;
 
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.customcommand.model.database.CustomCommand;
 
+import java.util.List;
 import java.util.Optional;
 
 public interface CustomCommandManagementService {
     Optional<CustomCommand> getCustomCommandByName(String name, Long serverId);
+    CustomCommand createCustomCommand(String name, String content, AUserInAServer creator);
+    void deleteCustomCommand(String name, AServer server);
+    List<CustomCommand> getCustomCommands(AServer server);
+    List<CustomCommand> getCustomCommandsStartingWith(String prefix, AServer server);
 }

abstracto-application/abstracto-modules/custom-command/custom-command-int/src/main/java/dev/sheldan/abstracto/customcommand/service/management/CustomCommandService.java

@@ -0,0 +1,15 @@
+package dev.sheldan.abstracto.customcommand.service.management;
+
+import dev.sheldan.abstracto.customcommand.model.database.CustomCommand;
+import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.Member;
+
+import java.util.List;
+
+public interface CustomCommandService {
+    CustomCommand createCustomCommand(String name, String content, Member creator);
+    void deleteCustomCommand(String name, Guild guild);
+    List<CustomCommand> getCustomCommands(Guild guild);
+    CustomCommand getCustomCommand(String name, Guild guild);
+    List<CustomCommand> getCustomCommandsStartingWith(String prefix, Guild guild);
+}

abstracto-application/abstracto-modules/custom-command/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>abstracto-modules</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.4.5</version>
+        <version>1.5.9</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/dynamic-activity/dynamic-activity-impl/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>dynamic-activity</artifactId>
-        <version>1.4.5</version>
+        <version>1.5.9</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/dynamic-activity/dynamic-activity-int/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>dynamic-activity</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.4.5</version>
+        <version>1.5.9</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/dynamic-activity/dynamic-activity-int/src/main/java/dev/sheldan/abstracto/activity/models/CustomActivity.java

@@ -2,7 +2,7 @@ package dev.sheldan.abstracto.activity.models;
 
 import lombok.*;
 
-import javax.persistence.*;
+import jakarta.persistence.*;
 import java.time.Instant;
 
 @Builder

abstracto-application/abstracto-modules/dynamic-activity/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>abstracto-modules</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.4.5</version>
+        <version>1.5.9</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/entertainment/entertainment-impl/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>entertainment</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.4.5</version>
+        <version>1.5.9</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/economy/Slots.java

@@ -89,14 +89,14 @@ public class Slots extends AbstractConditionableCommand {
                 .templated(true)
                 .build();
 
-        Parameter lowParameter = Parameter
+        Parameter bidParameter = Parameter
                 .builder()
                 .name(BID_PARAMETER)
                 .type(Integer.class)
                 .templated(true)
                 .validators(Arrays.asList(MinIntegerValueValidator.min(0L)))
                 .build();
-        parameters.add(lowParameter);
+        parameters.add(bidParameter);
 
         SlashCommandConfig slashCommandConfig = SlashCommandConfig
                 .builder()

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/economy/TransferCredits.java

@@ -11,10 +11,14 @@ import dev.sheldan.abstracto.core.interaction.InteractionService;
 import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
 import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
+import dev.sheldan.abstracto.core.service.ChannelService;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
 import dev.sheldan.abstracto.entertainment.config.EntertainmentSlashCommandNames;
+import dev.sheldan.abstracto.entertainment.model.command.TransferCreditsModel;
 import dev.sheldan.abstracto.entertainment.service.EconomyService;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
@@ -44,15 +48,25 @@ public class TransferCredits extends AbstractConditionableCommand {
     @Autowired
     private EconomyService economyService;
 
+    @Autowired
+    private ChannelService channelService;
+
     @Override
-    public CommandResult execute(CommandContext commandContext) {
+    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         List<Object> parameters = commandContext.getParameters().getParameters();
         Member targetMember = (Member) parameters.get(0);
         Integer amount = (Integer) parameters.get(1);
         AUserInAServer targetUser = userInServerManagementService.loadOrCreateUser(targetMember);
         AUserInAServer sourceUser = userInServerManagementService.loadOrCreateUser(commandContext.getAuthor());
         economyService.transferCredits(sourceUser, targetUser, amount.longValue());
-        return CommandResult.fromSuccess();
+        TransferCreditsModel responseModel = TransferCreditsModel
+                .builder()
+                .sourceMember(MemberDisplay.fromMember(commandContext.getAuthor()))
+                .targetMember(MemberDisplay.fromMember(targetMember))
+                .credits(amount)
+                .build();
+        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInTextChannelList(TRANSFER_CREDITS_RESPONSE, responseModel, commandContext.getChannel()))
+                .thenApply(unused -> CommandResult.fromSuccess());
     }
 
     @Override
@@ -61,8 +75,14 @@ public class TransferCredits extends AbstractConditionableCommand {
         Integer amount = slashCommandParameterService.getCommandOption(AMOUNT_PARAMETER, event, Integer.class);
         AUserInAServer targetUser = userInServerManagementService.loadOrCreateUser(targetMember);
         AUserInAServer sourceUser = userInServerManagementService.loadOrCreateUser(event.getMember());
+        TransferCreditsModel responseModel = TransferCreditsModel
+                .builder()
+                .sourceMember(MemberDisplay.fromMember(event.getMember()))
+                .targetMember(MemberDisplay.fromMember(targetMember))
+                .credits(amount)
+                .build();
         economyService.transferCredits(sourceUser, targetUser, amount.longValue());
-        return interactionService.replyEmbed(TRANSFER_CREDITS_RESPONSE, event)
+        return interactionService.replyEmbed(TRANSFER_CREDITS_RESPONSE, responseModel, event)
                 .thenApply(interactionHook -> CommandResult.fromSuccess());
     }
 
@@ -105,7 +125,8 @@ public class TransferCredits extends AbstractConditionableCommand {
                 .templated(true)
                 .supportsEmbedException(true)
                 .parameters(parameters)
-                .causesReaction(true)
+                .causesReaction(false)
+                .async(true)
                 .help(helpInfo)
                 .build();
     }

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/games/Mines.java

@@ -0,0 +1,230 @@
+package dev.sheldan.abstracto.entertainment.command.games;
+
+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.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.service.FeatureFlagService;
+import dev.sheldan.abstracto.core.templating.model.MessageToSend;
+import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentSlashCommandNames;
+import dev.sheldan.abstracto.entertainment.exception.NotEnoughCreditsException;
+import dev.sheldan.abstracto.entertainment.model.command.games.MineBoard;
+import dev.sheldan.abstracto.entertainment.model.database.EconomyUser;
+import dev.sheldan.abstracto.entertainment.service.GameService;
+import dev.sheldan.abstracto.entertainment.service.management.EconomyUserManagementService;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+public class Mines extends AbstractConditionableCommand {
+
+    private static final String MINES_COMMAND_NAME = "mines";
+    private static final String WIDTH_PARAMETER = "width";
+    private static final String HEIGHT_PARAMETER = "height";
+    private static final String MINES_PARAMETER = "mines";
+    private static final String CREDITS_PARAMETER = "credits";
+    public static final String MINE_BOARD_TEMPLATE_KEY = "mines_board_response";
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Autowired
+    private FeatureFlagService featureFlagService;
+
+    @Autowired
+    private GameService gameService;
+
+    @Autowired
+    private TemplateService templateService;
+
+    @Autowired
+    private EconomyUserManagementService economyUserManagementService;
+
+    @Autowired
+    private ChannelService channelService;
+
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        Integer width = 5;
+        if(slashCommandParameterService.hasCommandOption(WIDTH_PARAMETER, event)) {
+            width = slashCommandParameterService.getCommandOption(WIDTH_PARAMETER, event, Integer.class);
+        }
+        Integer height = 5;
+        if(slashCommandParameterService.hasCommandOption(HEIGHT_PARAMETER, event)) {
+            height = slashCommandParameterService.getCommandOption(HEIGHT_PARAMETER, event, Integer.class);
+        }
+        Integer mines = 5;
+        if(slashCommandParameterService.hasCommandOption(MINES_PARAMETER, event)) {
+            mines = slashCommandParameterService.getCommandOption(MINES_PARAMETER, event, Integer.class);
+        }
+        Integer credit = null;
+        long serverId = event.getGuild().getIdLong();
+        boolean economyEnabled = featureFlagService.getFeatureFlagValue(EntertainmentFeatureDefinition.ECONOMY, serverId);
+        if(economyEnabled){
+            credit = 50;
+            if(slashCommandParameterService.hasCommandOption(CREDITS_PARAMETER, event)) {
+                credit = slashCommandParameterService.getCommandOption(CREDITS_PARAMETER, event, Integer.class);
+            }
+
+            Optional<EconomyUser> userOptional = economyUserManagementService.getUser(ServerUser.fromMember(event.getMember()));
+            if(!userOptional.isPresent()) {
+                throw new NotEnoughCreditsException();
+            }
+            EconomyUser user = userOptional.get();
+            if(user.getCredits() < credit) {
+                throw new NotEnoughCreditsException();
+            }
+        }
+        MineBoard board = gameService.createBoard(width, height, mines, serverId);
+        board.setCreditsEnabled(economyEnabled);
+        board.setUserId(event.getMember().getIdLong());
+        board.setServerId(serverId);
+        board.setCredits(credit);
+        MessageToSend messageToSend = templateService.renderEmbedTemplate(MINE_BOARD_TEMPLATE_KEY, board);
+        return interactionService.replyMessageToSend(messageToSend, event)
+                .thenCompose(interactionHook -> interactionHook.retrieveOriginal().submit())
+                .thenApply(message -> {
+                    gameService.persistMineBoardMessage(board, message);
+                    return CommandResult.fromSuccess();
+                });
+    }
+
+
+    @Override
+    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
+        Integer width = 5;
+        List<Object> parameters = commandContext.getParameters().getParameters();
+        if(!parameters.isEmpty()) {
+            width = (Integer) parameters.get(0);
+        }
+        Integer height = 5;
+        if(parameters.size() >= 2) {
+            height = (Integer) parameters.get(1);
+        }
+        Integer mines = 5;
+        if(parameters.size() >= 3) {
+            mines = (Integer) parameters.get(2);
+        }
+        Integer credit = null;
+        long serverId = commandContext.getGuild().getIdLong();
+        boolean economyEnabled = featureFlagService.getFeatureFlagValue(EntertainmentFeatureDefinition.ECONOMY, serverId);
+        if(economyEnabled){
+            credit = 50;
+            if(parameters.size() == 4) {
+                credit = (Integer) parameters.get(3);
+            }
+
+            Optional<EconomyUser> userOptional = economyUserManagementService.getUser(ServerUser.fromMember(commandContext.getAuthor()));
+            if(!userOptional.isPresent()) {
+                throw new NotEnoughCreditsException();
+            }
+            EconomyUser user = userOptional.get();
+            if(user.getCredits() < credit) {
+                throw new NotEnoughCreditsException();
+            }
+        }
+        MineBoard board = gameService.createBoard(width, height, mines, serverId);
+        board.setCreditsEnabled(economyEnabled);
+        board.setUserId(commandContext.getAuthor().getIdLong());
+        board.setServerId(serverId);
+        board.setCredits(credit);
+        MessageToSend messageToSend = templateService.renderEmbedTemplate(MINE_BOARD_TEMPLATE_KEY, board);
+        List<CompletableFuture<Message>> futures = channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel());
+        return FutureUtils.toSingleFutureGeneric(futures)
+                .thenAccept(unused ->  gameService.persistMineBoardMessage(board, futures.get(0).join()))
+                .thenApply(unused -> CommandResult.fromSuccess());
+
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        List<Parameter> parameters = new ArrayList<>();
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        Parameter widthParameter = Parameter
+                .builder()
+                .name(WIDTH_PARAMETER)
+                .type(Integer.class)
+                .optional(true)
+                .templated(true)
+                .build();
+        parameters.add(widthParameter);
+
+        Parameter heightParameter = Parameter
+                .builder()
+                .name(HEIGHT_PARAMETER)
+                .type(Integer.class)
+                .optional(true)
+                .templated(true)
+                .build();
+        parameters.add(heightParameter);
+
+        Parameter minesParameter = Parameter
+                .builder()
+                .name(MINES_PARAMETER)
+                .type(Integer.class)
+                .optional(true)
+                .templated(true)
+                .build();
+        parameters.add(minesParameter);
+
+        Parameter creditsParameter = Parameter
+                .builder()
+                .name(CREDITS_PARAMETER)
+                .type(Integer.class)
+                .optional(true)
+                .templated(true)
+                .dependentFeatures(Arrays.asList(EntertainmentFeatureDefinition.ECONOMY.getKey()))
+                .build();
+        parameters.add(creditsParameter);
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(EntertainmentSlashCommandNames.GAME)
+                .commandName(MINES_COMMAND_NAME)
+                .build();
+
+        return CommandConfiguration.builder()
+                .name(MINES_COMMAND_NAME)
+                .slashCommandConfig(slashCommandConfig)
+                .async(true)
+                .module(EntertainmentModuleDefinition.ENTERTAINMENT)
+                .templated(true)
+                .supportsEmbedException(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return EntertainmentFeatureDefinition.GAMES;
+    }
+}

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/listener/interaction/MinesButtonClickedListener.java

@@ -0,0 +1,79 @@
+package dev.sheldan.abstracto.entertainment.listener.interaction;
+
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.config.ListenerPriority;
+import dev.sheldan.abstracto.core.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListener;
+import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListenerModel;
+import dev.sheldan.abstracto.core.interaction.button.listener.ButtonClickedListenerResult;
+import dev.sheldan.abstracto.core.service.FeatureFlagService;
+import dev.sheldan.abstracto.core.templating.model.MessageToSend;
+import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.entertainment.command.games.Mines;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
+import dev.sheldan.abstracto.entertainment.model.command.games.MineBoard;
+import dev.sheldan.abstracto.entertainment.model.command.games.MineBoardPayload;
+import dev.sheldan.abstracto.entertainment.service.GameService;
+import dev.sheldan.abstracto.entertainment.service.GameServiceBean;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+
+@Component
+@Slf4j
+public class MinesButtonClickedListener implements ButtonClickedListener {
+
+    @Autowired
+    private GameService gameService;
+
+    @Autowired
+    private TemplateService templateService;
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private FeatureFlagService featureFlagService;
+
+    @Override
+    public ButtonClickedListenerResult execute(ButtonClickedListenerModel model) {
+        MineBoardPayload payload = (MineBoardPayload) model.getDeserializedPayload();
+        if(model.getEvent().getUser().getIdLong() != payload.getMineBoard().getUserId()) {
+            return ButtonClickedListenerResult.IGNORED;
+        }
+        MineBoard mineBoard = payload.getMineBoard();
+        if(!mineBoard.getState().equals(GameService.MineResult.CONTINUE)) {
+            return ButtonClickedListenerResult.IGNORED;
+        }
+        GameService.MineResult mineResult = gameService.uncoverField(mineBoard, payload.getX(), payload.getY());
+        mineBoard.setState(mineResult);
+        if(mineBoard.getState() != GameService.MineResult.CONTINUE) {
+            if(featureFlagService.getFeatureFlagValue(EntertainmentFeatureDefinition.ECONOMY, model.getServerId())){
+                gameService.evaluateCreditChanges(mineBoard);
+            }
+            gameService.uncoverBoard(mineBoard);
+        }
+        MessageToSend messageToSend = templateService.renderEmbedTemplate(Mines.MINE_BOARD_TEMPLATE_KEY, mineBoard);
+        interactionService.editOriginal(messageToSend, model.getEvent().getHook()).thenAccept(message -> {
+            gameService.updateMineBoard(mineBoard);
+            log.info("Updated original mineboard for board {}.", mineBoard.getBoardId());
+        });
+        return ButtonClickedListenerResult.ACKNOWLEDGED;
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return EntertainmentFeatureDefinition.GAMES;
+    }
+
+    @Override
+    public Integer getPriority() {
+        return ListenerPriority.MEDIUM;
+    }
+
+    @Override
+    public Boolean handlesEvent(ButtonClickedListenerModel model) {
+        return model.getOrigin().equals(GameServiceBean.MINES_BUTTON_ORIGIN);
+    }
+}

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/repository/EconomyUserRepository.java

@@ -16,6 +16,7 @@ import java.util.Optional;
 @Repository
 public interface EconomyUserRepository extends JpaRepository<EconomyUser, Long> {
     Optional<EconomyUser> findByUser(AUserInAServer aUserInAServer);
+    Optional<EconomyUser> findByServer_IdAndUser_UserReference_Id(Long serverId, Long userId);
 
     @Query(value = "WITH economy_user_ranked AS" +
             "( " +

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/service/EconomyServiceBean.java

@@ -9,8 +9,6 @@ import dev.sheldan.abstracto.entertainment.dto.CreditGambleResult;
 import dev.sheldan.abstracto.entertainment.dto.PayDayResult;
 import dev.sheldan.abstracto.entertainment.dto.SlotsResult;
 import dev.sheldan.abstracto.entertainment.exception.NotEnoughCreditsException;
-import dev.sheldan.abstracto.entertainment.exception.PayDayCooldownException;
-import dev.sheldan.abstracto.entertainment.exception.SlotsCooldownException;
 import dev.sheldan.abstracto.entertainment.model.command.CreditsLeaderboardEntry;
 import dev.sheldan.abstracto.entertainment.model.database.EconomyLeaderboardResult;
 import dev.sheldan.abstracto.entertainment.model.database.EconomyUser;
@@ -19,14 +17,8 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
 import java.security.SecureRandom;
-import java.time.Duration;
-import java.time.Instant;
-import java.time.temporal.ChronoUnit;
 import java.util.*;
 
-import static dev.sheldan.abstracto.entertainment.config.EconomyFeatureConfig.PAYDAY_COOLDOWN_CONFIG_KEY;
-import static dev.sheldan.abstracto.entertainment.config.EconomyFeatureConfig.SLOTS_COOLDOWN_CONFIG_KEY;
-
 @Component
 public class EconomyServiceBean implements EconomyService {
 
@@ -70,42 +62,6 @@ public class EconomyServiceBean implements EconomyService {
     private static final Integer TRIPLE_FACTOR = 10;
     private static final Integer DOUBLE_FACTOR = 2;
 
-    @Override
-    public boolean canTriggerPayDay(AUserInAServer aUserInAServer) {
-        Optional<EconomyUser> userOptional = economyUserManagementService.getUser(aUserInAServer);
-        return userOptional.map(this::canTriggerPayDay).orElse(true);
-    }
-
-    @Override
-    public boolean canTriggerSlots(AUserInAServer aUserInAServer) {
-        Optional<EconomyUser> userOptional = economyUserManagementService.getUser(aUserInAServer);
-        return userOptional.map(this::canTriggerSlots).orElse(true);
-    }
-
-    @Override
-    public boolean canTriggerPayDay(EconomyUser economyUser) {
-        return slotsTriggerIn(economyUser).isNegative();
-    }
-
-    @Override
-    public boolean canTriggerSlots(EconomyUser economyUser) {
-        return payDayTriggerIn(economyUser).isNegative();
-    }
-
-    @Override
-    public Duration payDayTriggerIn(EconomyUser economyUser) {
-        Long cooldownSeconds = configService.getLongValueOrConfigDefault(PAYDAY_COOLDOWN_CONFIG_KEY, economyUser.getServer().getId());
-        Instant minTimeStamp = Instant.now().minus(cooldownSeconds, ChronoUnit.SECONDS);
-        return Duration.between(economyUser.getLastPayDay(), minTimeStamp);
-    }
-
-    @Override
-    public Duration slotsTriggerIn(EconomyUser economyUser) {
-        Long cooldownSeconds = configService.getLongValueOrConfigDefault(SLOTS_COOLDOWN_CONFIG_KEY, economyUser.getServer().getId());
-        Instant minTimeStamp = Instant.now().minus(cooldownSeconds, ChronoUnit.SECONDS);
-        return Duration.between(economyUser.getLastSlots(), minTimeStamp);
-    }
-
     @Override
     public EconomyUser addCredits(AUserInAServer aUserInAServer, Long credits) {
         Optional<EconomyUser> existingUserOptional = economyUserManagementService.getUser(aUserInAServer);
@@ -137,11 +93,6 @@ public class EconomyServiceBean implements EconomyService {
         Long creditsToAdd = configService.getLongValueOrConfigDefault(EconomyFeatureConfig.PAYDAY_CREDITS_CONFIG_KEY,
                 aUserInAServer.getServerReference().getId());
         EconomyUser economyUser = addCredits(aUserInAServer, creditsToAdd);
-        Duration durationForPayday = payDayTriggerIn(economyUser);
-        if (durationForPayday.isNegative()) {
-            throw new PayDayCooldownException(durationForPayday.abs());
-        }
-        economyUser.setLastPayDay(Instant.now());
         return PayDayResult
                 .builder()
                 .currentCredits(economyUser.getCredits())
@@ -160,17 +111,12 @@ public class EconomyServiceBean implements EconomyService {
         if(user.getCredits() < bid) {
             throw new NotEnoughCreditsException();
         }
-        Duration durationForSlots = slotsTriggerIn(user);
-        if (durationForSlots.isNegative()) {
-            throw new SlotsCooldownException(durationForSlots.abs());
-        }
         SlotGame slotGame = playSlots();
         Integer factor = slotGame.getResultFactor();
         Long creditChange = bid * factor;
         addCredits(user, -bid);
         addCredits(user, creditChange);
 
-        user.setLastSlots(Instant.now());
         return SlotsResult
                 .builder()
                 .bid(bid)

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/service/GameServiceBean.java

@@ -0,0 +1,312 @@
+package dev.sheldan.abstracto.entertainment.service;
+
+import dev.sheldan.abstracto.core.interaction.ComponentPayloadService;
+import dev.sheldan.abstracto.core.interaction.ComponentService;
+import dev.sheldan.abstracto.core.models.ServerUser;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.service.ConfigService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import dev.sheldan.abstracto.entertainment.exception.InvalidGameBoardException;
+import dev.sheldan.abstracto.entertainment.model.command.games.MineBoard;
+import dev.sheldan.abstracto.entertainment.model.command.games.MineBoardField;
+import dev.sheldan.abstracto.entertainment.model.command.games.MineBoardPayload;
+import dev.sheldan.abstracto.entertainment.model.command.games.MineBoardRow;
+import dev.sheldan.abstracto.entertainment.model.database.EconomyUser;
+import dev.sheldan.abstracto.entertainment.service.management.EconomyUserManagementService;
+import net.dv8tion.jda.api.entities.Message;
+import org.apache.commons.lang3.tuple.Pair;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.security.SecureRandom;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static dev.sheldan.abstracto.entertainment.config.GamesFeatureConfig.MINES_CREDITS_FACTOR;
+import static dev.sheldan.abstracto.entertainment.config.GamesFeatureConfig.MINES_MINIMUM_MINES_RATIO;
+
+@Component
+public class GameServiceBean implements GameService {
+
+    public static final String MINES_BUTTON_ORIGIN = "MINES_BUTTON";
+    @Autowired
+    private SecureRandom secureRandom;
+
+    @Autowired
+    private ComponentService componentService;
+
+    @Autowired
+    private ComponentPayloadService componentPayloadService;
+
+    @Autowired
+    private ServerManagementService serverManagementService;
+
+    @Autowired
+    private EconomyService economyService;
+
+    @Autowired
+    private EconomyUserManagementService economyUserManagementService;
+
+    @Autowired
+    private ConfigService configService;
+
+    @Override
+    public MineBoard createBoard(Integer width, Integer height, Integer mines, Long serverId) {
+        double minMinesRatio = configService.getDoubleValueOrConfigDefault(MINES_MINIMUM_MINES_RATIO, serverId);
+        if(mines >= width * height || width > 5 || height > 5 || mines <= 1 || height <= 1 || width <= 1) {
+            throw new InvalidGameBoardException(minMinesRatio);
+        }
+        if((double) mines / (width * height) < minMinesRatio) {
+            throw new InvalidGameBoardException(minMinesRatio);
+        }
+        MineBoard mineBoard = generateEmptyBoard(width, height);
+        mineBoard.setMineCount(mines);
+        fillWithMines(mineBoard);
+        evaluateCounters(mineBoard);
+
+        return mineBoard;
+    }
+
+    @Override
+    @Transactional
+    public void persistMineBoardMessage(MineBoard mineBoard, Message message) {
+        mineBoard.setMessageId(message.getIdLong());
+        mineBoard.setChannelId(message.getChannel().getIdLong());
+        AServer server = serverManagementService.loadServer(message.getGuild());
+        mineBoard.getFields().forEach(mineBoardField -> {
+            MineBoardPayload payload = MineBoardPayload
+                    .builder()
+                    .x(mineBoardField.getX())
+                    .y(mineBoardField.getY())
+                    .mineBoard(mineBoard)
+                    .build();
+            String componentId = mineBoard.getBoardId() + "_" + mineBoardField.getX() + "_" + mineBoardField.getY();
+            componentPayloadService.createButtonPayload(componentId, payload, MINES_BUTTON_ORIGIN, server);
+        });
+    }
+
+    @Override
+    @Transactional
+    public void updateMineBoard(MineBoard mineBoard) {
+        mineBoard.getFields().forEach(mineBoardField -> {
+            MineBoardPayload newPayload = MineBoardPayload
+                    .builder()
+                    .x(mineBoardField.getX())
+                    .y(mineBoardField.getY())
+                    .mineBoard(mineBoard)
+                    .build();
+            String componentId = mineBoard.getBoardId() + "_" + mineBoardField.getX() + "_" + mineBoardField.getY();
+            componentPayloadService.updateButtonPayload(componentId, newPayload);
+        });
+    }
+
+    @Override
+    public void uncoverBoard(MineBoard mineBoard) {
+        mineBoard.getFields().forEach(mineBoardField -> {
+            if(mineBoardField.getType().equals(MineBoardField.MineBoardFieldType.COVERED)) {
+                mineBoardField.setType(MineBoardField.MineBoardFieldType.UNCOVERED);
+            }
+        });
+    }
+
+    @Override
+    public void evaluateCreditChanges(MineBoard mineBoard) {
+        Long credits = mineBoard.getCredits().longValue();
+        Integer mineCount = mineBoard.getMineCount();
+        List<MineBoardField> allFields = mineBoard.getFields();
+        Integer leftFields = (int) allFields
+                .stream()
+                .filter(mineBoardField -> mineBoardField.getType().equals(MineBoardField.MineBoardFieldType.COVERED)
+                        || mineBoardField.getType().equals(MineBoardField.MineBoardFieldType.MINE))
+                .count();
+        Integer fieldCount = allFields.size();
+        Integer uncoveredFields = fieldCount - leftFields;
+        Long creditChange = (long) (calculateCreditFactor(fieldCount, mineCount, uncoveredFields) * credits);
+        if(mineBoard.getState().equals(MineResult.WON)) {
+            Double factor = configService.getDoubleValueOrConfigDefault(MINES_CREDITS_FACTOR, mineBoard.getServerId());
+            creditChange = (long) (creditChange * factor);
+        }
+        ServerUser serverUser = ServerUser
+                .builder()
+                .serverId(mineBoard.getServerId())
+                .userId(mineBoard.getUserId())
+                .build();
+        Optional<EconomyUser> economyUserOptional = economyUserManagementService.getUser(serverUser);
+        if(economyUserOptional.isPresent()) {
+            economyService.addCredits(economyUserOptional.get(), -credits);
+            economyService.addCredits(economyUserOptional.get(), creditChange);
+        }
+        mineBoard.setCreditChange(creditChange);
+    }
+
+    private double calculateCreditFactor(int totalFields, int mines, int uncovered) {
+        return ((double) uncovered / (totalFields - mines)) + totalFields / 25.0 - ((totalFields - mines) / 25.0);
+    }
+
+    @Override
+    public MineResult uncoverField(MineBoard board, Integer x, Integer y) {
+        return uncoverFieldOnBoard(board, x, y);
+    }
+
+    public GameService.MineResult uncoverFieldOnBoard(MineBoard board, Integer x, Integer y) {
+        MineBoardField field = board.getField(x, y);
+        if(!MineBoardField.canInteract(field.getType())) {
+            return GameService.MineResult.CONTINUE;
+        }
+        if(field.getType().equals(MineBoardField.MineBoardFieldType.MINE)) {
+            field.setType(MineBoardField.MineBoardFieldType.EXPLODED);
+            return GameService.MineResult.LOST;
+        }
+        if(field.getType().equals(MineBoardField.MineBoardFieldType.COVERED)) {
+            if(field.getCounterValue() == 0) {
+                Set<String> alreadyConsidered = new HashSet<>();
+                Queue<MineBoardField> toUncover = new LinkedList<>();
+                toUncover.add(field);
+                while(!toUncover.isEmpty()) {
+                    MineBoardField fieldToHandle = toUncover.poll();
+                    fieldToHandle.setType(MineBoardField.MineBoardFieldType.UNCOVERED);
+                    alreadyConsidered.add(fieldToHandle.getX() + "_" + fieldToHandle.getY());
+                    // only when we actually got a free field, we should add its neighbors to the next one to uncover
+                    if(fieldToHandle.getCounterValue() == 0) {
+                        List<MineBoardField> neighbors = getNeighbors(board, fieldToHandle.getX(), fieldToHandle.getY(), false);
+                        List<MineBoardField> uncoverableNeighbors = neighbors
+                                .stream().filter(mineBoardField -> mineBoardField.getType().equals(MineBoardField.MineBoardFieldType.COVERED))
+                                .collect(Collectors.toList());
+                        uncoverableNeighbors.forEach(mineBoardField -> {
+                            if(!alreadyConsidered.contains(mineBoardField.getX() + "_" + mineBoardField.getY())) {
+                                mineBoardField.setType(MineBoardField.MineBoardFieldType.UNCOVERED);
+                                // only if t he newly found neighbor is a free field, we should discover its neighbors
+                                if(mineBoardField.getCounterValue() == 0) {
+                                    toUncover.addAll(uncoverableNeighbors);
+                                }
+                            }
+                        });
+                    }
+                }
+            } else {
+                field.setType(MineBoardField.MineBoardFieldType.UNCOVERED);
+            }
+            if(hasWon(board)) {
+                return GameService.MineResult.WON;
+            }
+            return GameService.MineResult.CONTINUE;
+        }
+        throw new IllegalStateException("Did not find correct type of field.");
+    }
+
+    private List<MineBoardField> getNeighbors(MineBoard mineBoard, int xPosition, int yPosition) {
+        return getNeighbors(mineBoard, xPosition, yPosition, false);
+    }
+
+    private List<MineBoardField> getNeighbors(MineBoard board, int xPosition, int yPosition, boolean directOnly) {
+        List<MineBoardField> neighbors = new ArrayList<>();
+        boolean isFirstRow = yPosition == 0;
+        boolean isLastRow = yPosition == board.getRowCount() - 1;
+        boolean isFirstColumn = xPosition == 0;
+        boolean isLastColumn = xPosition == board.getColumnCount() - 1;
+        if(!isFirstColumn) {
+            if(!isFirstRow && !directOnly) {
+                neighbors.add(board.getField(xPosition - 1, yPosition - 1));
+            }
+            neighbors.add(board.getField(xPosition - 1, yPosition));
+            if(!isLastRow && !directOnly) {
+                neighbors.add(board.getField(xPosition - 1, yPosition + 1));
+            }
+        }
+        if(!isFirstRow && !directOnly) {
+            neighbors.add(board.getField(xPosition, yPosition - 1));
+        }
+        if(!isLastRow && !directOnly) {
+            neighbors.add(board.getField(xPosition, yPosition + 1));
+        }
+        if(!isLastColumn) {
+            if(!isFirstRow && !directOnly) {
+                neighbors.add(board.getField(xPosition + 1, yPosition - 1));
+            }
+            neighbors.add(board.getField(xPosition + 1, yPosition));
+            if(!isLastRow && !directOnly) {
+                neighbors.add(board.getField(xPosition + 1, yPosition + 1));
+            }
+        }
+        return neighbors;
+    }
+
+
+    public MineBoard generateEmptyBoard(Integer width, Integer height) {
+        List<MineBoardRow> rows = new ArrayList<>();
+        for (int y = 0; y < height; y++) {
+            List<MineBoardField> fields = new ArrayList<>();
+            for (int x = 0; x < width; x++) {
+                MineBoardField field = MineBoardField
+                        .builder()
+                        .y(y)
+                        .x(x)
+                        .counterValue(0)
+                        .type(MineBoardField.MineBoardFieldType.COVERED)
+                        .build();
+                fields.add(field);
+            }
+            MineBoardRow row = MineBoardRow
+                    .builder()
+                    .fields(fields)
+                    .build();
+            rows.add(row);
+        }
+        return MineBoard
+                .builder()
+                .rows(rows)
+                .state(MineResult.CONTINUE)
+                .columnCount(width)
+                .creditChange(0L)
+                .rowCount(height)
+                .boardId(UUID.randomUUID().toString())
+                .build();
+    }
+
+    public void fillWithMines(MineBoard board) {
+        Set<String> usedKeys = new HashSet<>();
+        int maxIterations = 1_0000_000;
+        int iterations = 0;
+        List<Pair<Integer, Integer>> foundPositions = new ArrayList<>();
+        do  {
+            int x = secureRandom.nextInt(board.getColumnCount());
+            int y = secureRandom.nextInt(board.getRowCount());
+            String positionKey = x + "_" + y;
+            if(!usedKeys.contains(positionKey)) {
+                foundPositions.add(Pair.of(x, y));
+                usedKeys.add(positionKey);
+                iterations = 0;
+            }
+            iterations++;
+        } while(foundPositions.size() < board.getMineCount() && iterations < maxIterations);
+        foundPositions.forEach(xYPair -> board.getRows().get(xYPair.getRight()).getFields().get(xYPair.getLeft()).setType(MineBoardField.MineBoardFieldType.MINE));
+    }
+
+    public void evaluateCounters(MineBoard board) {
+        board.getRows().forEach(mineBoardRow -> mineBoardRow.getFields().forEach(mineBoardField -> {
+            if(!mineBoardField.getType().equals(MineBoardField.MineBoardFieldType.MINE)) {
+                long mineCounts = getMineCounts(board, mineBoardField.getX(), mineBoardField.getY());
+                mineBoardField.setCounterValue((int) mineCounts);
+            }
+        }));
+    }
+
+    private long getMineCounts(MineBoard board, int xPosition, int yPosition) {
+        List<MineBoardField> neighbors = getNeighbors(board, xPosition, yPosition);
+        return neighbors
+                .stream()
+                .filter(mineBoardField -> mineBoardField.getType().equals(MineBoardField.MineBoardFieldType.MINE))
+                .count();
+    }
+
+    private boolean hasWon(MineBoard board) {
+        return board
+                .getFields()
+                .stream()
+                .noneMatch(mineBoardField ->
+                        mineBoardField.getType().equals(MineBoardField.MineBoardFieldType.COVERED)
+                        && !mineBoardField.getType().equals(MineBoardField.MineBoardFieldType.MINE));
+    }
+
+}

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/service/management/EconomyUserManagementServiceBean.java

@@ -1,5 +1,6 @@
 package dev.sheldan.abstracto.entertainment.service.management;
 
+import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.entertainment.model.database.EconomyLeaderboardResult;
@@ -26,8 +27,6 @@ public class EconomyUserManagementServiceBean implements EconomyUserManagementSe
                 .builder()
                 .id(aUserInAServer.getUserInServerId())
                 .server(aUserInAServer.getServerReference())
-                .lastPayDay(Instant.now().minus(1, ChronoUnit.DAYS))
-                .lastSlots(Instant.now().minus(1, ChronoUnit.DAYS))
                 .credits(0L)
                 .user(aUserInAServer)
                 .build();
@@ -39,6 +38,11 @@ public class EconomyUserManagementServiceBean implements EconomyUserManagementSe
         return repository.findByUser(aUserInAServer);
     }
 
+    @Override
+    public Optional<EconomyUser> getUser(ServerUser serverUser) {
+        return repository.findByServer_IdAndUser_UserReference_Id(serverUser.getServerId(), serverUser.getUserId());
+    }
+
     @Override
     public EconomyLeaderboardResult getRankOfUserInServer(AUserInAServer aUserInAServer) {
         return repository.getRankOfUserInServer(aUserInAServer.getUserInServerId(), aUserInAServer.getServerReference().getId());

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/entertainment-config.properties

@@ -10,16 +10,18 @@ abstracto.featureFlags.entertainment.enabled=false
 abstracto.systemConfigs.paydayCredits.name=paydayCredits
 abstracto.systemConfigs.paydayCredits.longValue=120
 
-# maybe replace this by command cooldowns which are globally on the server, instead of only channel group based
-abstracto.systemConfigs.paydayCooldown.name=paydayCooldown
-abstracto.systemConfigs.paydayCooldown.longValue=300
-
-abstracto.systemConfigs.slotsCooldown.name=slotsCooldown
-abstracto.systemConfigs.slotsCooldown.longValue=30
-
 abstracto.featureFlags.economy.featureName=economy
 abstracto.featureFlags.economy.enabled=false
 
+abstracto.featureFlags.games.featureName=games
+abstracto.featureFlags.games.enabled=false
+
+abstracto.systemConfigs.minesCreditsFactor.name=minesCreditsFactor
+abstracto.systemConfigs.minesCreditsFactor.doubleValue=5
+
+abstracto.systemConfigs.minesMinMineRatio.name=minesMinMineRatio
+abstracto.systemConfigs.minesMinMineRatio.doubleValue=0.2
+
 # for now this is fine
 abstracto.systemConfigs.creditGambleJackpot.name=creditGambleJackpot
 abstracto.systemConfigs.creditGambleJackpot.longValue=1000

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/1.4.11/collection.xml

@@ -0,0 +1,10 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
+    <include file="seedData/data.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/1.4.11/seedData/command.xml

@@ -0,0 +1,20 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
+    <property name="entertainmentModule" value="(SELECT id FROM module WHERE name = 'entertainment')"/>
+    <property name="gamesFeature" value="(SELECT id FROM feature WHERE key = 'games')"/>
+
+    <changeSet  author="Sheldan" id="mines-commands">
+        <insert tableName="command">
+            <column name="name" value="mines"/>
+            <column name="module_id" valueComputed="${entertainmentModule}"/>
+            <column name="feature_id" valueComputed="${gamesFeature}"/>
+        </insert>
+    </changeSet>
+
+</databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/1.4.11/seedData/data.xml

@@ -0,0 +1,11 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
+    <include file="feature.xml" relativeToChangelogFile="true"/>
+    <include file="command.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/1.4.11/seedData/feature.xml

@@ -0,0 +1,14 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
+    <changeSet author="Sheldan"  id="games_feature-insertion">
+        <insert tableName="feature">
+            <column name="key" value="games"/>
+        </insert>
+    </changeSet>
+</databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/1.5.8/cleanup/deletions.xml

@@ -0,0 +1,11 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
+    <include file="system_config.xml" relativeToChangelogFile="true"/>
+    <include file="economy_user.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/1.5.8/cleanup/economy_user.xml

@@ -0,0 +1,15 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
+    <changeSet author="Sheldan" id="economy_user-delete-cooldown-columns">
+        <dropColumn tableName="economy_user">
+            <column name="last_pay_day" />
+            <column name="last_slots" />
+        </dropColumn>
+    </changeSet>
+</databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/1.5.8/cleanup/system_config.xml

@@ -0,0 +1,19 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
+
+    <changeSet author="Sheldan" id="economy_cooldown-system-config-deletions">
+        <delete tableName="system_config">
+            <where>name='paydayCooldown'</where>
+        </delete>
+        <delete tableName="system_config">
+            <where>name='slotsCooldown'</where>
+        </delete>
+    </changeSet>
+
+</databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/1.5.8/collection.xml

@@ -0,0 +1,10 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog.xsd
+    http://www.liquibase.org/xml/ns/pro dbchangelog.xsd" >
+    <include file="cleanup/deletions.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/entertainment-changeLog.xml

@@ -11,4 +11,6 @@
     <include file="1.2.9-entertainment/collection.xml" relativeToChangelogFile="true"/>
     <include file="1.4.0/collection.xml" relativeToChangelogFile="true"/>
     <include file="1.4.3/collection.xml" relativeToChangelogFile="true"/>
+    <include file="1.4.11/collection.xml" relativeToChangelogFile="true"/>
+    <include file="1.5.8/collection.xml" relativeToChangelogFile="true"/>
 </databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-int/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>entertainment</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.4.5</version>
+        <version>1.5.9</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/config/EconomyFeatureConfig.java

@@ -11,8 +11,6 @@ import java.util.List;
 public class EconomyFeatureConfig implements FeatureConfig {
 
     public static final String PAYDAY_CREDITS_CONFIG_KEY = "paydayCredits";
-    public static final String PAYDAY_COOLDOWN_CONFIG_KEY = "paydayCooldown";
-    public static final String SLOTS_COOLDOWN_CONFIG_KEY = "slotsCooldown";
 
     @Override
     public FeatureDefinition getFeature() {
@@ -21,6 +19,6 @@ public class EconomyFeatureConfig implements FeatureConfig {
 
     @Override
     public List<String> getRequiredSystemConfigKeys() {
-        return Arrays.asList(PAYDAY_CREDITS_CONFIG_KEY, PAYDAY_COOLDOWN_CONFIG_KEY, SLOTS_COOLDOWN_CONFIG_KEY);
+        return Arrays.asList(PAYDAY_CREDITS_CONFIG_KEY);
     }
 }

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/config/EntertainmentFeatureDefinition.java

@@ -5,7 +5,7 @@ import lombok.Getter;
 
 @Getter
 public enum EntertainmentFeatureDefinition implements FeatureDefinition {
-    ENTERTAINMENT("entertainment"), ECONOMY("economy");
+    ENTERTAINMENT("entertainment"), ECONOMY("economy"), GAMES("games");
 
     private String key;
 

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/config/EntertainmentSlashCommandNames.java

@@ -4,4 +4,5 @@ public class EntertainmentSlashCommandNames {
     public static final String ENTERTAINMENT = "entertainment";
     public static final String UTILITY = "utility";
     public static final String ECONOMY = "economy";
+    public static final String GAME = "game";
 }

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/config/GamesFeatureConfig.java

@@ -0,0 +1,26 @@
+package dev.sheldan.abstracto.entertainment.config;
+
+import dev.sheldan.abstracto.core.config.FeatureConfig;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import org.springframework.stereotype.Component;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Component
+public class GamesFeatureConfig implements FeatureConfig {
+
+    public static final String MINES_CREDITS_FACTOR = "minesCreditsFactor";
+    public static final String MINES_MINIMUM_MINES_RATIO = "minesMinMineRatio";
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return EntertainmentFeatureDefinition.GAMES;
+    }
+
+    @Override
+    public List<String> getRequiredSystemConfigKeys() {
+        return Arrays.asList(MINES_CREDITS_FACTOR, MINES_MINIMUM_MINES_RATIO);
+    }
+
+}

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/exception/InvalidGameBoardException.java

@@ -0,0 +1,27 @@
+package dev.sheldan.abstracto.entertainment.exception;
+
+import dev.sheldan.abstracto.core.exception.AbstractoTemplatableException;
+import dev.sheldan.abstracto.entertainment.model.exception.InvalidGameBoardExceptionModel;
+
+public class InvalidGameBoardException extends AbstractoTemplatableException {
+
+    private final InvalidGameBoardExceptionModel model;
+
+    public InvalidGameBoardException(Double minRatio) {
+        super();
+        this.model = InvalidGameBoardExceptionModel
+                .builder()
+                .minMinesRatio(minRatio)
+                .build();
+    }
+
+    @Override
+    public String getTemplateName() {
+        return "invalid_mine_board_config_exception";
+    }
+
+    @Override
+    public Object getTemplateModel() {
+        return model;
+    }
+}

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/exception/PayDayCooldownException.java

@@ -1,28 +0,0 @@
-package dev.sheldan.abstracto.entertainment.exception;
-
-import dev.sheldan.abstracto.core.exception.AbstractoTemplatableException;
-import dev.sheldan.abstracto.entertainment.model.exception.PayDayCooldownExceptionModel;
-
-import java.time.Duration;
-
-public class PayDayCooldownException extends AbstractoTemplatableException {
-
-    private final PayDayCooldownExceptionModel model;
-
-    public PayDayCooldownException(Duration duration) {
-        this.model = PayDayCooldownExceptionModel
-                .builder()
-                .tryAgainDuration(duration)
-                .build();
-    }
-
-    @Override
-    public String getTemplateName() {
-        return "payday_cooldown_exception";
-    }
-
-    @Override
-    public Object getTemplateModel() {
-        return model;
-    }
-}

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/exception/SlotsCooldownException.java

@@ -1,28 +0,0 @@
-package dev.sheldan.abstracto.entertainment.exception;
-
-import dev.sheldan.abstracto.core.exception.AbstractoTemplatableException;
-import dev.sheldan.abstracto.entertainment.model.exception.SlotsCooldownExceptionModel;
-
-import java.time.Duration;
-
-public class SlotsCooldownException extends AbstractoTemplatableException {
-
-    private final SlotsCooldownExceptionModel model;
-
-    public SlotsCooldownException(Duration duration) {
-        this.model = SlotsCooldownExceptionModel
-                .builder()
-                .tryAgainDuration(duration)
-                .build();
-    }
-
-    @Override
-    public String getTemplateName() {
-        return "slots_cooldown_exception";
-    }
-
-    @Override
-    public Object getTemplateModel() {
-        return model;
-    }
-}

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/command/TransferCreditsModel.java

@@ -0,0 +1,13 @@
+package dev.sheldan.abstracto.entertainment.model.command;
+
+import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
+import lombok.Builder;
+import lombok.Getter;
+
+@Builder
+@Getter
+public class TransferCreditsModel {
+    private Integer credits;
+    private MemberDisplay sourceMember;
+    private MemberDisplay targetMember;
+}

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/command/games/MineBoard.java

@@ -0,0 +1,44 @@
+package dev.sheldan.abstracto.entertainment.model.command.games;
+
+import dev.sheldan.abstracto.entertainment.service.GameService;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Getter
+@Setter
+@Builder
+public class MineBoard {
+    private String boardId;
+    private Long userId;
+    private Long serverId;
+    private Long messageId;
+    private Long channelId;
+    private Integer rowCount;
+    private Integer columnCount;
+    private Integer credits;
+    private Long creditChange;
+    private boolean creditsEnabled;
+    private Integer mineCount;
+    private List<MineBoardRow> rows;
+    private GameService.MineResult state;
+
+    public MineBoardField getField(int x, int y) {
+        if(x > columnCount || y > rowCount) {
+            throw new IllegalArgumentException("Out of bounds access to board.");
+        }
+        MineBoardRow mineBoardRow = rows.get(y);
+        return mineBoardRow.getFields().get(x);
+    }
+
+    public List<MineBoardField> getFields() {
+        List<MineBoardField> fields = new ArrayList<>();
+        rows.forEach(mineBoardRow -> fields.addAll(mineBoardRow.getFields()));
+        return fields;
+    }
+
+
+}

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/command/games/MineBoardField.java

@@ -0,0 +1,25 @@
+package dev.sheldan.abstracto.entertainment.model.command.games;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Builder
+@Setter
+public class MineBoardField {
+    private MineBoardField.MineBoardFieldType type;
+    private Integer x;
+    private Integer y;
+    private Integer counterValue;
+
+    public enum MineBoardFieldType {
+        MINE, UNCOVERED, COVERED, EXPLODED
+    }
+
+    public static boolean canInteract(MineBoardFieldType currentType) {
+        return currentType != MineBoardFieldType.UNCOVERED && currentType != MineBoardFieldType.EXPLODED;
+    }
+
+}
+

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/command/games/MineBoardPayload.java

@@ -0,0 +1,15 @@
+package dev.sheldan.abstracto.entertainment.model.command.games;
+
+import dev.sheldan.abstracto.core.interaction.button.ButtonPayload;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Builder
+@Setter
+public class MineBoardPayload implements ButtonPayload {
+    private MineBoard mineBoard;
+    private Integer x;
+    private Integer y;
+}

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/command/games/MineBoardRow.java

@@ -0,0 +1,12 @@
+package dev.sheldan.abstracto.entertainment.model.command.games;
+
+import lombok.Builder;
+import lombok.Getter;
+
+import java.util.List;
+
+@Getter
+@Builder
+public class MineBoardRow {
+    private List<MineBoardField> fields;
+}

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/database/EconomyUser.java

@@ -4,7 +4,7 @@ import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import lombok.*;
 
-import javax.persistence.*;
+import jakarta.persistence.*;
 import java.io.Serializable;
 import java.time.Instant;
 
@@ -33,12 +33,6 @@ public class EconomyUser implements Serializable {
     @Column(name = "credits", nullable = false)
     private Long credits;
 
-    @Column(name = "last_slots", nullable = false)
-    private Instant lastSlots;
-
-    @Column(name = "last_pay_day", nullable = false)
-    private Instant lastPayDay;
-
     @Column(name = "created", nullable = false, insertable = false, updatable = false)
     private Instant created;
 

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/exception/InvalidGameBoardExceptionModel.java

@@ -0,0 +1,10 @@
+package dev.sheldan.abstracto.entertainment.model.exception;
+
+import lombok.Builder;
+import lombok.Getter;
+
+@Getter
+@Builder
+public class InvalidGameBoardExceptionModel {
+    private Double minMinesRatio;
+}

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/service/EconomyService.java

@@ -10,16 +10,9 @@ import dev.sheldan.abstracto.entertainment.model.database.EconomyUser;
 import lombok.Builder;
 import lombok.Getter;
 
-import java.time.Duration;
 import java.util.List;
 
 public interface EconomyService {
-    boolean canTriggerPayDay(AUserInAServer aUserInAServer);
-    boolean canTriggerSlots(AUserInAServer aUserInAServer);
-    boolean canTriggerPayDay(EconomyUser economyUser);
-    boolean canTriggerSlots(EconomyUser economyUser);
-    Duration payDayTriggerIn(EconomyUser economyUser);
-    Duration slotsTriggerIn(EconomyUser economyUser);
     EconomyUser addCredits(AUserInAServer aUserInAServer, Long credits);
     void addCredits(EconomyUser economyUser, Long credits);
     void addPayDayCredits(AUserInAServer aUserInAServer);

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/service/GameService.java

@@ -0,0 +1,18 @@
+package dev.sheldan.abstracto.entertainment.service;
+
+import dev.sheldan.abstracto.entertainment.model.command.games.MineBoard;
+import net.dv8tion.jda.api.entities.Message;
+
+public interface GameService {
+    MineBoard createBoard(Integer width, Integer height, Integer mines, Long serverId);
+    void persistMineBoardMessage(MineBoard mineBoard, Message message);
+    void updateMineBoard(MineBoard mineBoard);
+    void uncoverBoard(MineBoard mineBoard);
+    void evaluateCreditChanges(MineBoard mineBoard);
+    MineResult uncoverField(MineBoard board, Integer x, Integer y);
+
+
+    enum MineResult {
+        WON, LOST, CONTINUE
+    }
+}

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/service/management/EconomyUserManagementService.java

@@ -1,5 +1,6 @@
 package dev.sheldan.abstracto.entertainment.service.management;
 
+import dev.sheldan.abstracto.core.models.ServerUser;
 import dev.sheldan.abstracto.core.models.database.AServer;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.entertainment.model.database.EconomyLeaderboardResult;
@@ -11,6 +12,7 @@ import java.util.Optional;
 public interface EconomyUserManagementService {
     EconomyUser createUser(AUserInAServer aUserInAServer);
     Optional<EconomyUser> getUser(AUserInAServer aUserInAServer);
+    Optional<EconomyUser> getUser(ServerUser serverUser);
     EconomyLeaderboardResult getRankOfUserInServer(AUserInAServer aUserInAServer);
     List<EconomyUser> getRanksInServer(AServer server, Integer page, Integer size);
 }

abstracto-application/abstracto-modules/entertainment/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>abstracto-modules</artifactId>
         <groupId>dev.sheldan.abstracto.modules</groupId>
-        <version>1.4.5</version>
+        <version>1.5.9</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <groupId>dev.sheldan.abstracto.modules</groupId>
         <artifactId>experience-tracking</artifactId>
-        <version>1.4.5</version>
+        <version>1.5.9</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/command/ExpLevelUpNotification.java

@@ -0,0 +1,103 @@
+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.interaction.InteractionService;
+import dev.sheldan.abstracto.core.interaction.slash.SlashCommandConfig;
+import dev.sheldan.abstracto.core.interaction.slash.parameter.SlashCommandParameterService;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
+import dev.sheldan.abstracto.experience.config.ExperienceFeatureDefinition;
+import dev.sheldan.abstracto.experience.config.ExperienceSlashCommandNames;
+import dev.sheldan.abstracto.experience.service.AUserExperienceService;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Component
+public class ExpLevelUpNotification extends AbstractConditionableCommand {
+
+    private static final String FLAG_PARAMETER = "newValue";
+    private static final String EXP_LEVEL_UP_NOTIFICATION_COMMAND = "expLevelUpNotification";
+    private static final String EXP_LEVEL_UP_NOTIFICATION_RESPONSE = "expLevelUpNotification_response";
+
+    @Autowired
+    private UserInServerManagementService userInServerManagementService;
+
+    @Autowired
+    private AUserExperienceService aUserExperienceService;
+
+    @Autowired
+    private InteractionService interactionService;
+
+    @Autowired
+    private SlashCommandParameterService slashCommandParameterService;
+
+    @Override
+    public CommandResult execute(CommandContext commandContext) {
+        Boolean newValue = (Boolean) commandContext.getParameters().getParameters().get(0);
+        updateExpLevelNotification(commandContext.getAuthor(), newValue);
+        return CommandResult.fromSuccess();
+    }
+
+    @Override
+    public CompletableFuture<CommandResult> executeSlash(SlashCommandInteractionEvent event) {
+        Boolean newValue = slashCommandParameterService.getCommandOption(FLAG_PARAMETER, event, Boolean.class);
+        updateExpLevelNotification(event.getMember(), newValue);
+        return interactionService.replyEmbed(EXP_LEVEL_UP_NOTIFICATION_RESPONSE, event)
+                .thenApply(interactionHook -> CommandResult.fromSuccess());
+    }
+
+    private void updateExpLevelNotification(Member member, Boolean newValue) {
+        AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(member);
+        aUserExperienceService.setLevelUpNotification(aUserInAServer, newValue);
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return ExperienceFeatureDefinition.EXPERIENCE;
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        Parameter memberParameter = Parameter
+                .builder()
+                .name(FLAG_PARAMETER)
+                .templated(true)
+                .type(Boolean.class)
+                .build();
+        List<Parameter> parameters = Arrays.asList(memberParameter);
+        HelpInfo helpInfo = HelpInfo
+                .builder()
+                .templated(true)
+                .build();
+
+        SlashCommandConfig slashCommandConfig = SlashCommandConfig
+                .builder()
+                .enabled(true)
+                .rootCommandName(ExperienceSlashCommandNames.EXPERIENCE)
+                .commandName(EXP_LEVEL_UP_NOTIFICATION_COMMAND)
+                .build();
+
+        return CommandConfiguration.builder()
+                .name(EXP_LEVEL_UP_NOTIFICATION_COMMAND)
+                .module(ExperienceModuleDefinition.EXPERIENCE)
+                .slashCommandConfig(slashCommandConfig)
+                .causesReaction(true)
+                .supportsEmbedException(true)
+                .templated(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+}

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/command/Rank.java

@@ -104,7 +104,17 @@ public class Rank extends AbstractConditionableCommand {
         AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(toRender);
         AUserExperience experienceObj = userExperienceManagementService.findUserInServer(aUserInAServer);
         log.info("Rendering rank for user {} in server {}.", toRender.getId(), toRender.getGuild().getId());
-        rankModel.setExperienceToNextLevel(experienceLevelService.calculateExperienceToNextLevel(experienceObj.getCurrentLevel().getLevel(), experienceObj.getExperience()));
+        Long currentExpNeeded = experienceObj.getCurrentLevel().getExperienceNeeded();
+        Long experienceNeededToNextLevel = experienceLevelService.calculateExperienceToNextLevel(experienceObj.getCurrentLevel().getLevel(), experienceObj.getExperience());
+        Long nextLevelExperience = experienceLevelService.calculateNextLevel(experienceObj.getCurrentLevel().getLevel()).getExperienceNeeded();
+        Long levelExperience = nextLevelExperience - currentExpNeeded;
+        Long inLevelExperience = experienceObj.getExperience() - currentExpNeeded;
+        rankModel.setExperienceForCurrentLevel(currentExpNeeded);
+        rankModel.setCurrentLevelPercentage(((float) inLevelExperience / levelExperience) * 100);
+        rankModel.setLevelExperience(levelExperience);
+        rankModel.setExperienceToNextLevel(experienceNeededToNextLevel);
+        rankModel.setInLevelExperience(inLevelExperience);
+        rankModel.setNextLevelExperience(nextLevelExperience);
         return templateService.renderEmbedTemplate(RANK_POST_EMBED_TEMPLATE, rankModel, toRender.getGuild().getIdLong());
     }
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/command/SetExpRole.java

@@ -10,8 +10,6 @@ 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.exception.EntityGuildMismatchException;
-import dev.sheldan.abstracto.core.service.RoleService;
-import dev.sheldan.abstracto.core.service.management.RoleManagementService;
 import dev.sheldan.abstracto.experience.config.ExperienceFeatureDefinition;
 import dev.sheldan.abstracto.experience.service.ExperienceRoleService;
 import lombok.extern.slf4j.Slf4j;
@@ -34,12 +32,6 @@ public class SetExpRole extends AbstractConditionableCommand {
     @Autowired
     private ExperienceRoleService experienceRoleService;
 
-    @Autowired
-    private RoleService roleService;
-
-    @Autowired
-    private RoleManagementService roleManagementService;
-
     @Override
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         Integer level = (Integer) commandContext.getParameters().getParameters().get(0);
@@ -48,7 +40,7 @@ public class SetExpRole extends AbstractConditionableCommand {
             throw new EntityGuildMismatchException();
         }
         log.info("Setting role  {} to be used for level {} on server {}", role.getId(), level, role.getGuild().getId());
-        return experienceRoleService.setRoleToLevel(role, level, commandContext.getChannel().getIdLong())
+        return experienceRoleService.setRoleToLevel(role, level, commandContext.getChannel())
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 
@@ -56,8 +48,21 @@ public class SetExpRole extends AbstractConditionableCommand {
     public CommandConfiguration getConfiguration() {
         List<Parameter> parameters = new ArrayList<>();
         List<ParameterValidator> levelValidators = Arrays.asList(MinIntegerValueValidator.min(0L));
-        parameters.add(Parameter.builder().name("level").validators(levelValidators).templated(true).type(Integer.class).build());
-        parameters.add(Parameter.builder().name("role").templated(true).type(Role.class).build());
+        Parameter level = Parameter
+                .builder()
+                .name("level")
+                .validators(levelValidators)
+                .templated(true)
+                .type(Integer.class)
+                .build();
+        parameters.add(level);
+        Parameter role = Parameter
+                .builder()
+                .name("role")
+                .templated(true)
+                .type(Role.class)
+                .build();
+        parameters.add(role);
         HelpInfo helpInfo = HelpInfo.builder().templated(true).hasExample(true).build();
         return CommandConfiguration.builder()
                 .name("setExpRole")

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/command/SyncRoles.java

@@ -39,7 +39,7 @@ public class SyncRoles extends AbstractConditionableCommand {
     public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
         AServer server =  serverManagementService.loadServer(commandContext.getGuild());
         log.info("Synchronizing roles on server {}", server.getId());
-        return userExperienceService.syncUserRolesWithFeedback(server, commandContext.getChannel().getIdLong())
+        return userExperienceService.syncUserRolesWithFeedback(server, commandContext.getChannel())
                 .thenApply(aVoid -> CommandResult.fromIgnored());
     }
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/command/UnSetExpRole.java

@@ -52,7 +52,7 @@ public class UnSetExpRole extends AbstractConditionableCommand {
         if(!experienceRole.isPresent()) {
             throw new ExperienceRoleNotFoundException();
         }
-        return experienceRoleService.unsetRoles(actualRole, commandContext.getChannel().getIdLong())
+        return experienceRoleService.unsetRoles(actualRole, commandContext.getChannel())
                 .thenApply(aVoid -> CommandResult.fromSuccess());
     }
 

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

@@ -1,6 +1,5 @@
 package dev.sheldan.abstracto.experience.job;
 
-import dev.sheldan.abstracto.experience.model.ServerExperience;
 import dev.sheldan.abstracto.experience.service.AUserExperienceService;
 import dev.sheldan.abstracto.experience.service.RunTimeExperienceService;
 import lombok.extern.slf4j.Slf4j;
@@ -12,10 +11,6 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.scheduling.quartz.QuartzJobBean;
 import org.springframework.stereotype.Component;
 
-import java.time.Instant;
-import java.util.List;
-import java.util.Map;
-
 
 /**
  * This {@link QuartzJobBean job} is executed regularly and calls the the {@link AUserExperienceService service}
@@ -26,10 +21,7 @@ import java.util.Map;
 @DisallowConcurrentExecution
 @Component
 @PersistJobDataAfterExecution
-public class ExperiencePersistingJob extends QuartzJobBean {
-
-    @Autowired
-    private AUserExperienceService userExperienceService;
+public class ExperienceCleanupJob extends QuartzJobBean {
 
     @Autowired
     private RunTimeExperienceService runTimeExperienceService;
@@ -37,19 +29,9 @@ public class ExperiencePersistingJob extends QuartzJobBean {
     @Override
     protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
         runTimeExperienceService.takeLock();
+        log.info("Cleaning up experience runtime storage.");
         try {
-            Map<Long, List<ServerExperience>> runtimeExperience = runTimeExperienceService.getRuntimeExperience();
-            log.info("Running experience persisting job.");
-            Long pastMinute = (Instant.now().getEpochSecond() / 60) - 1;
-            if(runtimeExperience.containsKey(pastMinute)) {
-                List<ServerExperience> foundServers = runtimeExperience.get(pastMinute);
-                log.info("Found experience from {} servers to persist.", foundServers.size());
-                userExperienceService.handleExperienceGain(foundServers).thenAccept(aVoid -> {
-                    runTimeExperienceService.takeLock();
-                    runTimeExperienceService.getRuntimeExperience().remove(pastMinute);
-                    runTimeExperienceService.releaseLock();
-                });
-            }
+            runTimeExperienceService.cleanupRunTimeStorage();
         } finally {
             runTimeExperienceService.releaseLock();
         }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/listener/ExperienceTrackerListener.java

@@ -4,9 +4,7 @@ import dev.sheldan.abstracto.core.config.FeatureDefinition;
 import dev.sheldan.abstracto.core.listener.DefaultListenerResult;
 import dev.sheldan.abstracto.core.listener.async.jda.AsyncMessageReceivedListener;
 import dev.sheldan.abstracto.core.listener.sync.jda.MessageReceivedListener;
-import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.models.listener.MessageReceivedModel;
-import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
 import dev.sheldan.abstracto.experience.config.ExperienceFeatureDefinition;
 import dev.sheldan.abstracto.experience.service.AUserExperienceService;
 import lombok.extern.slf4j.Slf4j;
@@ -25,9 +23,6 @@ public class ExperienceTrackerListener implements AsyncMessageReceivedListener {
     @Autowired
     private AUserExperienceService userExperienceService;
 
-    @Autowired
-    private UserInServerManagementService userInServerManagementService;
-
     @Override
     public DefaultListenerResult execute(MessageReceivedModel model) {
         Message message = model.getMessage();
@@ -35,8 +30,7 @@ public class ExperienceTrackerListener implements AsyncMessageReceivedListener {
             return DefaultListenerResult.IGNORED;
         }
         if(userExperienceService.experienceGainEnabledInChannel(message.getChannel())) {
-            AUserInAServer cause = userInServerManagementService.loadOrCreateUser(model.getServerId(), model.getMessage().getAuthor().getIdLong());
-            userExperienceService.addExperience(cause);
+            userExperienceService.addExperience(message.getMember(), model.getMessage());
             return DefaultListenerResult.PROCESSED;
         } else  {
             return DefaultListenerResult.IGNORED;

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/listener/JoiningUserRoleListener.java

@@ -37,12 +37,16 @@ public class JoiningUserRoleListener implements AsyncJoinListener {
 
     @Override
     public DefaultListenerResult execute(MemberJoinModel model) {
+        if(model.getMember().isPending()) {
+            log.info("Joining member {} in guild {} is still pending - ignoring for experience role assignment.", model.getJoiningUser().getUserId(), model.getJoiningUser().getServerId());
+            return DefaultListenerResult.IGNORED;
+        }
         Optional<AUserInAServer> userInAServerOptional = userInServerManagementService.loadUserOptional(model.getServerId(), model.getJoiningUser().getUserId());
         userInAServerOptional.ifPresent(aUserInAServer -> {
             Optional<AUserExperience> userExperienceOptional = userExperienceManagementService.findByUserInServerIdOptional(aUserInAServer.getUserInServerId());
             if(userExperienceOptional.isPresent()) {
                 log.info("User {} joined {} with previous experience. Setting up experience role again (if necessary).", model.getJoiningUser().getUserId(), model.getServerId());
-                userExperienceService.syncForSingleUser(userExperienceOptional.get()).thenAccept(result ->
+                userExperienceService.syncForSingleUser(userExperienceOptional.get(), model.getMember(), true).thenAccept(result ->
                         log.info("Finished re-assigning experience for re-joining user {} in server {}.", model.getJoiningUser().getUserId(), model.getServerId())
                 );
             } else {

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/listener/MemberPendingRoleListener.java

@@ -0,0 +1,60 @@
+package dev.sheldan.abstracto.experience.listener;
+
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.listener.DefaultListenerResult;
+import dev.sheldan.abstracto.core.listener.async.jda.AsyncUpdatePendingListener;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
+import dev.sheldan.abstracto.core.models.listener.MemberUpdatePendingModel;
+import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
+import dev.sheldan.abstracto.experience.config.ExperienceFeatureDefinition;
+import dev.sheldan.abstracto.experience.model.database.AUserExperience;
+import dev.sheldan.abstracto.experience.service.AUserExperienceService;
+import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.Member;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.Optional;
+
+/**
+ * If a {@link Member member} updates the pending status, this {@link AsyncUpdatePendingListener listener} retrieves the previously stored {@link AUserExperience experience} and gives the
+ * member the necessary {@link net.dv8tion.jda.api.entities.Role role} according to the current configuration, if any
+ */
+@Component
+@Slf4j
+public class MemberPendingRoleListener implements AsyncUpdatePendingListener {
+
+    @Autowired
+    private UserExperienceManagementService userExperienceManagementService;
+
+    @Autowired
+    private AUserExperienceService userExperienceService;
+
+    @Autowired
+    private UserInServerManagementService userInServerManagementService;
+
+    @Override
+    public DefaultListenerResult execute(MemberUpdatePendingModel model) {
+        Optional<AUserInAServer> userInAServerOptional = userInServerManagementService.loadUserOptional(model.getServerId(), model.getUser().getUserId());
+        userInAServerOptional.ifPresent(aUserInAServer -> {
+            Optional<AUserExperience> userExperienceOptional = userExperienceManagementService.findByUserInServerIdOptional(aUserInAServer.getUserInServerId());
+            if(userExperienceOptional.isPresent()) {
+                log.info("User {} updated pending status {} with previous experience. Setting up experience role again (if necessary).", model.getUser().getUserId(), model.getServerId());
+                userExperienceService.syncForSingleUser(userExperienceOptional.get(), model.getMember(), true).thenAccept(result ->
+                        log.info("Finished re-assigning experience for update pending user {} in server {}.", model.getUser().getUserId(), model.getServerId())
+                );
+            } else {
+                log.info("Member updating pending {} in server {} does not have any previous experience. Not setting up anything.", model.getUser().getUserId(), model.getServerId());
+            }
+        });
+
+        return DefaultListenerResult.PROCESSED;
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return ExperienceFeatureDefinition.EXPERIENCE;
+    }
+
+}

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

@@ -21,6 +21,7 @@ public interface ExperienceRoleRepository extends JpaRepository<AExperienceRole,
      * @return The {@link AExperienceRole experienceRole} found or null if the query did not return any results
      */
     Optional<AExperienceRole> findByRole(ARole role);
+    List<AExperienceRole> findByRole_IdIn(List<Long> role);
 
     /**
      * Finds a list of {@link AExperienceRole experienceRoles} (if there are multiple ones, because of misconfiguration) of the given

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

@@ -5,6 +5,7 @@ import dev.sheldan.abstracto.experience.model.database.AUserExperience;
 import dev.sheldan.abstracto.experience.model.database.LeaderBoardEntryResult;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
@@ -52,4 +53,8 @@ public interface UserExperienceRepository  extends JpaRepository<AUserExperience
             "WHERE rank.id = :userInServerId", nativeQuery = true)
     LeaderBoardEntryResult getRankOfUserInServer(@Param("userInServerId") Long id, @Param("serverId") Long serverId);
 
+    @Modifying(clearAutomatically = true)
+    @Query("update AUserExperience u set u.currentExperienceRole = null where u.currentExperienceRole.id = :roleId")
+    void removeExperienceRoleFromUsers(@Param("roleId") Long experienceRoleId);
+
 }

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

@@ -1,36 +1,51 @@
 package dev.sheldan.abstracto.experience.service;
 
 import dev.sheldan.abstracto.core.models.database.*;
-import dev.sheldan.abstracto.core.models.property.SystemConfigProperty;
+import dev.sheldan.abstracto.core.models.template.display.MemberDisplay;
+import dev.sheldan.abstracto.core.models.template.display.RoleDisplay;
 import dev.sheldan.abstracto.core.service.*;
-import dev.sheldan.abstracto.core.service.management.*;
+import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
+import dev.sheldan.abstracto.core.service.management.ServerManagementService;
+import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
+import dev.sheldan.abstracto.core.templating.model.MessageToSend;
+import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import dev.sheldan.abstracto.core.utils.CompletableFutureList;
 import dev.sheldan.abstracto.core.utils.FutureUtils;
 import dev.sheldan.abstracto.experience.config.ExperienceFeatureConfig;
+import dev.sheldan.abstracto.experience.config.ExperienceFeatureDefinition;
+import dev.sheldan.abstracto.experience.config.ExperienceFeatureMode;
 import dev.sheldan.abstracto.experience.exception.NoExperienceTrackedException;
-import dev.sheldan.abstracto.experience.model.*;
+import dev.sheldan.abstracto.experience.model.LeaderBoard;
+import dev.sheldan.abstracto.experience.model.LeaderBoardEntry;
+import dev.sheldan.abstracto.experience.model.RoleCalculationResult;
 import dev.sheldan.abstracto.experience.model.database.*;
+import dev.sheldan.abstracto.experience.model.template.LevelUpNotificationModel;
 import dev.sheldan.abstracto.experience.model.template.UserSyncStatusModel;
 import dev.sheldan.abstracto.experience.service.management.DisabledExpRoleManagementService;
 import dev.sheldan.abstracto.experience.service.management.ExperienceLevelManagementService;
 import dev.sheldan.abstracto.experience.service.management.ExperienceRoleManagementService;
 import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
-import dev.sheldan.abstracto.core.templating.model.MessageToSend;
-import dev.sheldan.abstracto.core.templating.service.TemplateService;
 import lombok.extern.slf4j.Slf4j;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
+import org.apache.commons.collections4.ListUtils;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.core.task.TaskExecutor;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.security.SecureRandom;
 import java.time.Instant;
+import java.time.temporal.ChronoUnit;
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
-import java.util.function.Function;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
 
+import static dev.sheldan.abstracto.experience.config.ExperienceFeatureConfig.EXP_COOLDOWN_SECONDS_KEY;
+
 @Component
 @Slf4j
 public class AUserExperienceServiceBean implements AUserExperienceService {
@@ -81,38 +96,52 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
     private ChannelGroupService channelGroupService;
 
     @Autowired
-    private DefaultConfigManagementService defaultConfigManagementService;
+    private SecureRandom secureRandom;
+
+    @Autowired
+    private ChannelService channelService;
+
+    @Autowired
+    private FeatureModeService featureModeService;
 
     @Autowired
     private AUserExperienceServiceBean self;
 
+    @Autowired
+    @Qualifier("experienceUpdateExecutor")
+    private TaskExecutor experienceUpdateExecutor;
+
     @Override
-    public void addExperience(AUserInAServer userInAServer) {
+    public void addExperience(Member member, Message message) {
         runTimeExperienceService.takeLock();
         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(), serverId);
-                List<ServerExperience> existing = runtimeExperience.get(minute);
-                for (ServerExperience server : existing) {
-                    if (server.getServerId().equals(serverId) && server.getUserInServerIds().stream().noneMatch(userInServerId::equals)) {
-                        server.getUserInServerIds().add(userInServerId);
-                        break;
+            Map<Long, Map<Long, Instant>> runtimeExperience = runTimeExperienceService.getRuntimeExperience();
+            Long serverId = member.getGuild().getIdLong();
+            Long userId = member.getIdLong();
+            boolean receivesNewExperience = false;
+            if(!runtimeExperience.containsKey(serverId)) {
+                runtimeExperience.put(serverId, new HashMap<>());
+                receivesNewExperience = true;
+            } else {
+                Map<Long, Instant> serverExperience = runtimeExperience.get(serverId);
+                if(!serverExperience.containsKey(userId)) {
+                    receivesNewExperience = true;
+                } else {
+                    Instant latestExperience = serverExperience.get(userId);
+                    if(latestExperience.isBefore(Instant.now())) {
+                        receivesNewExperience = true;
                     }
                 }
-
-            } else {
-                log.debug("Minute {} did not exist yet. Creating new entry for user {} in server {}.", minute, userInAServer.getUserReference().getId(), serverId);
-                ServerExperience serverExperience = ServerExperience
-                        .builder()
-                        .serverId(serverId)
-                        .build();
-                serverExperience.getUserInServerIds().add(userInServerId);
-                runtimeExperience.put(minute, new ArrayList<>(Arrays.asList(serverExperience)));
+            }
+            if(receivesNewExperience) {
+                Map<Long, Instant> serverExperience = runtimeExperience.get(serverId);
+                // we store when the user is eligible for experience _again_
+                Long maxSeconds = configService.getLongValueOrConfigDefault(EXP_COOLDOWN_SECONDS_KEY, serverId);
+                serverExperience.put(userId, Instant.now().plus(maxSeconds, ChronoUnit.SECONDS));
+                CompletableFuture.runAsync(() -> self.addExperienceToMember(member, message), experienceUpdateExecutor).exceptionally(throwable -> {
+                    log.error("Failed to add experience to member {} in server {}.", message.getAuthor().getId(), message.getGuild().getIdLong(), throwable);
+                    return null;
+                });
             }
         } finally {
             runTimeExperienceService.releaseLock();
@@ -148,317 +177,229 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
         return false;
     }
 
-    @Transactional
     @Override
-    public CompletableFuture<Void> handleExperienceGain(List<ServerExperience> servers) {
-        List<ExperienceGainResult> resultFutures = new ArrayList<>();
-        List<CompletableFuture<RoleCalculationResult>> futures = new ArrayList<>();
-        CompletableFuture<Void> experienceFuture = new CompletableFuture<>();
-        // TODO what if there are a lot in here...., transaction size etc
-        servers.forEach(serverExp -> {
-            List<CompletableFuture<Member>> memberFutures = new ArrayList<>();
-            serverExp.getUserInServerIds().forEach(userInAServerId -> {
-                AUserInAServer userInAServer = userInServerManagementService.loadOrCreateUser(userInAServerId);
-                CompletableFuture<Member> memberFuture = memberService.getMemberInServerAsync(userInAServer);
-                memberFutures.add(memberFuture);
-            });
+    public CompletableFuture<Void> syncUserRolesWithFeedback(AServer server, MessageChannel messageChannel) {
+        List<AUserExperience> aUserExperiences = userExperienceManagementService.loadAllUsers(server);
+        List<Long> userIds = aUserExperiences
+                .stream()
+                .map(aUserExperience -> aUserExperience.getUser().getUserReference().getId())
+                .collect(Collectors.toList());
+        log.info("Synchronizing experience roles for {} users.", userIds.size());
+        CompletableFuture<Void> returnFuture = new CompletableFuture<>();
+        Long serverId = server.getId();
+        int supposedUserCount = userIds.size();
 
-            FutureUtils.toSingleFutureGeneric(memberFutures).whenComplete((unused, throwable) -> {
-                self.updateFoundMembers(memberFutures, serverExp.getServerId(), resultFutures, futures);
-                experienceFuture.complete(null);
+        List<List<Long>> partitionedUserIds = ListUtils.partition(userIds, 100);
+        List<CompletableFuture<List<Member>>> memberLoadingFutures = new ArrayList<>();
+        for (List<Long> userIdsPart : partitionedUserIds) {
+            memberLoadingFutures.add(memberService.getMembersInServerAsync(server.getId(), userIdsPart));
+            try {
+                Thread.sleep(500L);
+            } catch (InterruptedException e) {
+                log.error("Failed to sleep.", e);
+            }
+        }
+        CompletableFutureList<List<Member>> listCompletableFutureList = new CompletableFutureList<>(memberLoadingFutures);
+        listCompletableFutureList.getMainFuture().whenComplete((result, throwable) -> {
+                List<Member> members = new ArrayList<>();
+                listCompletableFutureList.getFutures().forEach(listCompletableFuture -> members.addAll(listCompletableFuture.join()));
+                if(throwable != null) {
+                    log.warn("Failed to load all members in server {} for syncing experience. We started with {} and got {}.",
+                            serverId, supposedUserCount, members.size(), throwable);
+                }
+                self.syncUsers(members, serverId, messageChannel).thenAccept(unused -> {
+                    log.info("Finished syncing users for experience roles.");
+                    returnFuture.complete(null);
+                }).exceptionally(throwable1 -> {
+                    log.error("Failed to sync members.", throwable);
+                    returnFuture.complete(null);
+                    return null;
+                });
             }).exceptionally(throwable -> {
-                experienceFuture.completeExceptionally(throwable);
+                log.error("Failed to load members.", throwable);
+                returnFuture.complete(null);
                 return null;
-            });
         });
-        return experienceFuture
-                .thenCompose(unused -> FutureUtils.toSingleFutureGeneric(futures))
-                .whenComplete((unused, throwable) -> self.persistExperienceChanges(resultFutures));
+        return returnFuture;
     }
 
     @Transactional
-    public void updateFoundMembers(List<CompletableFuture<Member>> memberFutures, Long serverId, List<ExperienceGainResult> resultFutures, List<CompletableFuture<RoleCalculationResult>> futures) {
-        List<AExperienceLevel> levels = experienceLevelManagementService.getLevelConfig();
-        SystemConfigProperty defaultExpMultiplier = defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY);
-        SystemConfigProperty defaultMinExp = defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MIN_EXP_KEY);
-        SystemConfigProperty defaultMaxExp = defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MAX_EXP_KEY);
-        AServer server = serverManagementService.loadOrCreate(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());
-        PrimitiveIterator.OfInt iterator = new Random().ints(memberFutures.size(), minExp, maxExp + 1).iterator();
-        levels.sort(Comparator.comparing(AExperienceLevel::getExperienceNeeded));
+    public CompletableFuture<Void> syncUsers(List<Member> members, Long serverId, MessageChannel messageChannel) {
+        AtomicInteger currentCount = new AtomicInteger();
+        MessageToSend status = getUserSyncStatusUpdateModel(0, members.size(), serverId);
+        Message statusMessage = messageService.createStatusMessage(status, messageChannel).join();
+
+        AServer server = serverManagementService.loadServer(serverId);
         List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);
-        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 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());
-                            Long newMessageCount = aUserExperience.getMessageCount() + 1L;
-                            ExperienceGainResult calculationResult =
-                                    ExperienceGainResult
-                                            .builder()
-                                            .calculationResult(resultFuture)
-                                            .newExperience(newExperienceCount)
-                                            .newMessageCount(newMessageCount)
-                                            .newLevel(newLevel.getLevel())
-                                            .serverId(serverId)
-                                            .userInServerId(userInAServer.getUserInServerId())
-                                            .build();
-                            resultFutures.add(calculationResult);
-                            futures.add(resultFuture);
-                        } else {
-                            log.debug("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()
-                                        .calculationResult(resultFuture)
-                                        .newExperience(newExperience)
-                                        .newMessageCount(newMessageCount)
-                                        .newLevel(newLevel.getLevel())
-                                        .createUserExperience(true)
-                                        .userInServerId(userInAServer.getUserInServerId())
-                                        .build();
-                        resultFutures.add(calculationResult);
-                        futures.add(resultFuture);
-                    }
-                } else {
-                    log.debug("User {} has a role which makes the user unable to gain experience.", userInAServer.getUserInServerId());
-                }
-            }
+
+        List<CompletableFuture<Void>> futures = members
+                .stream()
+                .map(member -> this.syncUser(member, roles)
+                        .thenAccept(unused -> {
+                            currentCount.set(currentCount.get() + 1);
+                            log.debug("Finished synchronizing {} users.", currentCount.get());
+                            if(currentCount.get() % 50 == 0) {
+                                log.info("Notifying for {} current users with synchronize.", currentCount.get());
+                                MessageToSend newStatus = getUserSyncStatusUpdateModel(currentCount.get(), members.size(), serverId);
+                                messageService.updateStatusMessage(messageChannel, statusMessage.getIdLong(), newStatus);
+                            }
+                        }))
+                .collect(Collectors.toList());
+        return FutureUtils.toSingleFutureGeneric(futures).thenAccept(unused -> {
+            MessageToSend newStatus = getUserSyncStatusUpdateModel(currentCount.get(), members.size(), serverId);
+            messageService.updateStatusMessage(messageChannel, statusMessage.getIdLong(), newStatus);
         });
     }
 
-    /**
-     * Calculates the appropriate {@link AExperienceRole experienceRole} based on the current level and awards the referenced the {@link AUserInAServer userinAServer}
-     * the {@link net.dv8tion.jda.api.entities.Role role}. If the user already left the guild, this will not award a {@link net.dv8tion.jda.api.entities.Role}, but just
-     * return the instance in order to be persisted
-     * @param aUserInAServer The {@link AUserInAServer userInAServer} which does not have a {@link AUserExperience userExperience} object,
-     *                       therefore we need to calculate the appropriate role and award the role
-     * @param roles A list of {@link AExperienceRole experienceRoles} representing the configuration which is used to calculate the appropriate
-     *              {@link AExperienceRole experienceRole}
-     * @param currentLevel The current level of the user which was reached.
-     * @return A {@link CompletableFuture future} containing the {@link RoleCalculationResult result} of the role calculation, which completes after the user has been awarded the role.
-     */
-    private CompletableFuture<RoleCalculationResult> applyInitialRole(AUserInAServer aUserInAServer, List<AExperienceRole> roles, Integer currentLevel) {
-        AExperienceRole role = experienceRoleService.calculateRole(roles, currentLevel);
-        if(role == null) {
-            log.debug("No experience role calculated. Applying none to user {} in server {}.",
-                    aUserInAServer.getUserReference().getId(), aUserInAServer.getServerReference().getId());
-            return CompletableFuture.completedFuture(RoleCalculationResult
-                    .builder()
-                    .userInServerId(aUserInAServer.getUserInServerId())
-                    .experienceRoleId(null)
-                    .build());
-        }
-        Long experienceRoleId = role.getId();
-        Long userInServerId = aUserInAServer.getUserInServerId();
-        log.debug("Applying {} as the first experience role for user {} in server {}.",
-                experienceRoleId, aUserInAServer.getUserReference().getId(), aUserInAServer.getServerReference().getId());
-        return roleService.addRoleToUserAsync(aUserInAServer, role.getRole()).thenApply(aVoid -> RoleCalculationResult
-                .builder()
-                .experienceRoleId(experienceRoleId)
-                .userInServerId(userInServerId)
-                .build());
+    public CompletableFuture<Void> syncUser(Member member, List<AExperienceRole> roles) {
+        AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(member);
+        AUserExperience userExperience = userExperienceManagementService.findByUserInServerId(aUserInAServer.getUserInServerId());
+        return  calculateAndApplyExperienceRole(userExperience, member, roles, false);
     }
 
-    /**
-     * Persists the list of {@link ExperienceGainResult results} in the database. If the creation of {@link AUserExperience userExperience} object was requested,
-     * this will happen here, also the correct level is selected
-     * @param resultFutures A list of {@link ExperienceGainResult results} which define what should be changed for the given {@link AUserExperience userExperience} object:
-     *                      The level, experience, experienceRole, message account could change, or the object could not even exist
-     */
-    @Transactional
-    public void persistExperienceChanges(List<ExperienceGainResult> resultFutures) {
-        // we do have the _value_ of the level, but we require the actual instance
-        Map<Integer, AExperienceLevel> levels = experienceLevelManagementService.getLevelConfigAsMap();
-        log.info("Storing {} experience gain results.", resultFutures.size());
-        HashMap<Long, List<AExperienceRole>> serverRoleMapping = new HashMap<>();
-        resultFutures.forEach(experienceGainResult -> {
-            AUserInAServer user = userInServerManagementService.loadOrCreateUser(experienceGainResult.getUserInServerId());
-            AUserExperience userExperience;
-            if(experienceGainResult.isCreateUserExperience()) {
-                userExperience = userExperienceManagementService.createUserInServer(user);
-                log.info("Creating new experience user for user in server {}.", experienceGainResult.getUserInServerId());
+    @Override
+    public CompletableFuture<Void> syncForSingleUser(AUserExperience userExperience, Member member, boolean forceRoles) {
+        List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(userExperience.getServer());
+        roles.sort(Comparator.comparing(role -> role.getLevel().getLevel()));
+        return calculateAndApplyExperienceRole(userExperience, member, roles, forceRoles);
+    }
+
+    private CompletableFuture<Void> calculateAndApplyExperienceRole(AUserExperience userExperience, Member member, List<AExperienceRole> roles, boolean forceRoles) {
+        AExperienceRole calculatedNewRole = experienceRoleService.calculateRole(roles, userExperience.getCurrentLevel().getLevel());
+        Long oldRoleId = userExperience.getCurrentExperienceRole() != null && userExperience.getCurrentExperienceRole().getRole() != null ? userExperience.getCurrentExperienceRole().getRole().getId() : null;
+        Long newRoleId = calculatedNewRole != null ? calculatedNewRole.getRole().getId() : null;
+
+        userExperience.setCurrentExperienceRole(calculatedNewRole);
+
+        CompletableFuture<Void> returningFuture;
+        if(!Objects.equals(oldRoleId, newRoleId) || forceRoles) {
+            CompletableFuture<Void> addingFuture;
+            if(oldRoleId != null) {
+                addingFuture = roleService.removeRoleFromMemberAsync(member, oldRoleId);
             } else {
-                userExperience = userExperienceManagementService.findByUserInServerId(experienceGainResult.getUserInServerId());
+                addingFuture = CompletableFuture.completedFuture(null);
             }
-            userExperience.setMessageCount(experienceGainResult.getNewMessageCount());
-            userExperience.setExperience(experienceGainResult.getNewExperience());
-            // only search the levels if the level changed, or if there is no level currently set
-            AExperienceLevel currentLevel = userExperience.getCurrentLevel();
-            boolean userExperienceHasLevel = currentLevel != null;
-            if(!userExperienceHasLevel || !currentLevel.getLevel().equals(experienceGainResult.getNewLevel())) {
-                AExperienceLevel foundLevel = levels.get(experienceGainResult.getNewLevel());
-                if(foundLevel != null) {
-                    log.info("User {} in server {} changed the level. Old level {}. New level {}.", experienceGainResult.getUserInServerId(), experienceGainResult.getServerId(), currentLevel.getLevel(), experienceGainResult.getNewLevel());
-                    userExperience.setCurrentLevel(foundLevel);
-                } else {
-                    log.warn("User {} was present, but no level matching the calculation result {} could be found.", userExperience.getUser().getUserReference().getId(), experienceGainResult.getNewLevel());
-                }
+            CompletableFuture<Void> removingFeature;
+            if(newRoleId != null) {
+                removingFeature = roleService.addRoleToMemberAsync(member, newRoleId);
+            } else {
+                removingFeature = CompletableFuture.completedFuture(null);
             }
-            AServer server = user.getServerReference();
-            // "Caching" the experience roles for this server
-            if(!serverRoleMapping.containsKey(server.getId())) {
-                serverRoleMapping.put(server.getId(), experienceRoleManagementService.getExperienceRolesForServer(server));
-            }
-            RoleCalculationResult roleCalculationResult = experienceGainResult.getCalculationResult().join();
-            if(roleCalculationResult.getExperienceRoleId() != null) {
-                AExperienceRole role = experienceRoleManagementService.getExperienceRoleById(roleCalculationResult.getExperienceRoleId());
-                userExperience.setCurrentExperienceRole(role);
-            }
-            if(experienceGainResult.isCreateUserExperience()) {
-                userExperienceManagementService.saveUser(userExperience);
-            }
-        });
-    }
-
-    @Override
-    public CompletableFuture<RoleCalculationResult> updateUserRole(AUserExperience userExperience, List<AExperienceRole> roles, Integer currentLevel) {
-        AUserInAServer user = userExperience.getUser();
-        Function<Void, RoleCalculationResult> returnNullRole = aVoid -> RoleCalculationResult
-                .builder()
-                .userInServerId(user.getUserInServerId())
-                .experienceRoleId(null)
-                .build();
-        Long userInServerId = user.getUserInServerId();
-        Long serverId = user.getServerReference().getId();
-        log.debug("Updating experience role for user {} in server {}", user.getUserReference().getId(), serverId);
-        AExperienceRole role = experienceRoleService.calculateRole(roles, currentLevel);
-        boolean currentlyHasNoExperienceRole = userExperience.getCurrentExperienceRole() == null;
-        // if calculation results in no role, do not add a role
-        if(role == null) {
-            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 && !userExperience.getCurrentExperienceRole().getRole().getDeleted()){
-                return roleService.removeRoleFromUserAsync(user, userExperience.getCurrentExperienceRole().getRole())
-                        .thenApply(returnNullRole);
-            }
-            return CompletableFuture.completedFuture(returnNullRole.apply(null));
+            returningFuture = CompletableFuture.allOf(addingFuture, removingFeature);
+        } else {
+            returningFuture = CompletableFuture.completedFuture(null);
         }
-        Long experienceRoleId = role.getId();
-        Long roleId = role.getRole().getId();
-        // if the new role is already the one configured in the database
-        Long userId = user.getUserReference().getId();
-        Long oldUserExperienceRoleId = currentlyHasNoExperienceRole ? 0L : userExperience.getCurrentExperienceRole().getRole().getId();
-        return memberService.getMemberInServerAsync(user).thenCompose(member -> {
-            boolean userHasRoleAlready = roleService.memberHasRole(member, roleId);
-            boolean userHasOldRole = false;
-            boolean rolesChanged = true;
-            if(!currentlyHasNoExperienceRole) {
-                userHasOldRole = roleService.memberHasRole(member, oldUserExperienceRoleId);
-                rolesChanged = !roleId.equals(oldUserExperienceRoleId);
-            }
-            Function<Void, RoleCalculationResult> fullResult = aVoid -> RoleCalculationResult
-                    .builder()
-                    .experienceRoleId(experienceRoleId)
-                    .userInServerId(userInServerId)
-                    .build();
-            // 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) {
-                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.addRoleToMemberAsync(member, roleId);
-                } else {
-                    addRoleFuture = CompletableFuture.completedFuture(null);
-                }
-                return CompletableFuture.allOf(removalFuture, addRoleFuture).thenApply(fullResult);
-            }
-            // we are turning the full calculation result regardless
-            return CompletableFuture.completedFuture(fullResult.apply(null));
-        });
+        return returningFuture;
     }
 
-    @Override
-    public List<CompletableFuture<RoleCalculationResult>> syncUserRoles(AServer server) {
-        List<CompletableFuture<RoleCalculationResult>> results = new ArrayList<>();
-        List<AUserExperience> aUserExperiences = userExperienceManagementService.loadAllUsers(server);
-        log.info("Found {} users to synchronize", aUserExperiences.size());
-        List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);
-        roles.sort(Comparator.comparing(role -> role.getLevel().getLevel()));
-        for (int i = 0; i < aUserExperiences.size(); i++) {
-            AUserExperience userExperience = aUserExperiences.get(i);
-            log.info("Synchronizing {} out of {}. User in Server {}.", i, aUserExperiences.size(), userExperience.getUser().getUserInServerId());
-            results.add(updateUserRole(userExperience, roles, userExperience.getCurrentLevel().getLevel()));
-        }
-        return results;
-    }
-
-    @Override
-    public CompletableFuture<Void> syncUserRolesWithFeedback(AServer server, Long channelId) {
-        AChannel channel = channelManagementService.loadChannel(channelId);
-        List<AUserExperience> aUserExperiences = userExperienceManagementService.loadAllUsers(server);
-        log.info("Found {} users to synchronize", aUserExperiences.size());
-        List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);
-        roles.sort(Comparator.comparing(role -> role.getLevel().getLevel()));
-        CompletableFutureList<RoleCalculationResult> calculations = executeActionOnUserExperiencesWithFeedBack(aUserExperiences, channel, (AUserExperience experience) -> updateUserRole(experience, roles, experience.getLevelOrDefault()));
-        return calculations.getMainFuture().thenAccept(aVoid ->
-            self.syncRolesInStorage(calculations.getObjects())
-        );
-    }
-
-    /**
-     * Updates the actually stored experience roles in the database
-     * @param results The list of {@link RoleCalculationResult results} which should be applied
-     */
     @Transactional
-    public void syncRolesInStorage(List<RoleCalculationResult> results) {
-        HashMap<Long, AExperienceRole> experienceRoleHashMap = new HashMap<>();
-        results.forEach(result -> {
-            if(result != null) {
-                AUserInAServer user = userInServerManagementService.loadOrCreateUser(result.getUserInServerId());
-                AUserExperience userExperience = userExperienceManagementService.findUserInServer(user);
-                log.debug("Updating experience role for {} in server {} to {}", user.getUserInServerId(), user.getServerReference().getId(), result.getExperienceRoleId());
-                if(result.getExperienceRoleId() != null) {
-                    log.debug("User experience {} gets new experience role with id {}.", userExperience.getId(), result.getExperienceRoleId());
-                    AExperienceRole role;
-                    if(!experienceRoleHashMap.containsKey(result.getExperienceRoleId())) {
-                        role = experienceRoleManagementService.getExperienceRoleById(result.getExperienceRoleId());
-                        experienceRoleHashMap.put(result.getExperienceRoleId(), role);
-                    } else {
-                        role = experienceRoleHashMap.get(result.getExperienceRoleId());
-                    }
-                    userExperience.setCurrentExperienceRole(role);
+    public void addExperienceToMember(Member member, Message message) {
+        long serverId = member.getGuild().getIdLong();
+        AServer server = serverManagementService.loadOrCreate(serverId);
+        List<ADisabledExpRole> disabledExpRoles = disabledExpRoleManagementService.getDisabledRolesForServer(server);
+        List<ARole> disabledRoles = disabledExpRoles
+                .stream()
+                .map(ADisabledExpRole::getRole)
+                .collect(Collectors.toList());
+        if(roleService.hasAnyOfTheRoles(member, disabledRoles)) {
+            log.debug("User {} has a experience disable role in server {} - not giving any experience.", member.getIdLong(), serverId);
+            return;
+        }
+        List<AExperienceLevel> levels = experienceLevelManagementService.getLevelConfig();
+        levels.sort(Comparator.comparing(AExperienceLevel::getExperienceNeeded));
+
+        Long minExp = configService.getLongValueOrConfigDefault(ExperienceFeatureConfig.MIN_EXP_KEY, serverId);
+        Long maxExp = configService.getLongValueOrConfigDefault(ExperienceFeatureConfig.MAX_EXP_KEY, serverId);
+        Double multiplier = configService.getDoubleValueOrConfigDefault(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverId);
+        Long experienceRange = maxExp - minExp + 1;
+        Long gainedExperience = (secureRandom.nextInt(experienceRange.intValue()) + minExp);
+        gainedExperience = (long) Math.floor(gainedExperience * multiplier);
+
+        List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);
+        roles.sort(Comparator.comparing(role -> role.getLevel().getLevel()));
+
+        AUserInAServer userInAServer = userInServerManagementService.loadOrCreateUser(member);
+        Long userInServerId = userInAServer.getUserInServerId();
+        log.debug("Handling {}. The user might gain {}.", userInServerId, gainedExperience);
+        Optional<AUserExperience> aUserExperienceOptional = userExperienceManagementService.findByUserInServerIdOptional(userInAServer.getUserInServerId());
+        AUserExperience aUserExperience = aUserExperienceOptional.orElseGet(() -> userExperienceManagementService.createUserInServer(userInAServer));
+        if(Boolean.FALSE.equals(aUserExperience.getExperienceGainDisabled())) {
+            Long oldExperience = aUserExperience.getExperience();
+            Long newExperienceCount = oldExperience + gainedExperience;
+            aUserExperience.setExperience(newExperienceCount);
+            AExperienceLevel newLevel = calculateLevel(levels, newExperienceCount);
+            RoleCalculationResult result = RoleCalculationResult
+                    .builder()
+                    .build();
+            if(!Objects.equals(newLevel.getLevel(), aUserExperience.getCurrentLevel().getLevel())) {
+                Integer oldLevel = aUserExperience.getCurrentLevel() != null ? aUserExperience.getCurrentLevel().getLevel() : 0;
+                log.info("User {} in server {} changed level. New {}, Old {}.", member.getIdLong(),
+                        member.getGuild().getIdLong(), newLevel.getLevel(),
+                        oldLevel);
+                aUserExperience.setCurrentLevel(newLevel);
+                AExperienceRole calculatedNewRole = experienceRoleService.calculateRole(roles, newLevel.getLevel());
+                Long oldRoleId = aUserExperience.getCurrentExperienceRole() != null && aUserExperience.getCurrentExperienceRole().getRole() != null ? aUserExperience.getCurrentExperienceRole().getRole().getId() : null;
+                Long newRoleId = calculatedNewRole != null && calculatedNewRole.getRole() != null ? calculatedNewRole.getRole().getId() : null;
+                result.setOldRoleId(oldRoleId);
+                result.setNewRoleId(newRoleId);
+                if(message != null
+                        && aUserExperience.getLevelUpNotification()
+                        && featureModeService.featureModeActive(ExperienceFeatureDefinition.EXPERIENCE, serverId, ExperienceFeatureMode.LEVEL_UP_NOTIFICATION)) {
+                    LevelUpNotificationModel model = LevelUpNotificationModel
+                            .builder()
+                            .memberDisplay(MemberDisplay.fromMember(member))
+                            .oldExperience(oldExperience)
+                            .newExperience(newExperienceCount)
+                            .newLevel(newLevel.getLevel())
+                            .oldLevel(oldLevel)
+                            .newRole(oldRoleId != null ? RoleDisplay.fromRole(oldRoleId) : null)
+                            .newRole(newRoleId != null ? RoleDisplay.fromRole(newRoleId) : null)
+                            .build();
+                    MessageToSend messageToSend = templateService.renderEmbedTemplate("experience_level_up_notification", model);
+                    FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, message.getChannel())).thenAccept(unused -> {
+                        log.info("Sent level up notification to user {} in server {} in channel {}.", member.getIdLong(), serverId, message.getChannel().getIdLong());
+                    }).exceptionally(throwable -> {
+                        log.warn("Failed to send level up notification to user {} in server {} in channel {}.", member.getIdLong(), serverId, message.getChannel().getIdLong());
+                        return null;
+                    });
+                }
+                aUserExperience.setCurrentExperienceRole(calculatedNewRole);
+            }
+            aUserExperience.setMessageCount(aUserExperience.getMessageCount() + 1L);
+            if(!aUserExperienceOptional.isPresent()) {
+                userExperienceManagementService.saveUser(aUserExperience);
+            }
+            if(!Objects.equals(result.getOldRoleId(), result.getNewRoleId())) {
+                if(result.getOldRoleId() != null && result.getNewRoleId() != null) {
+                    roleService.updateRolesIds(member, Arrays.asList(result.getOldRoleId()), Arrays.asList(result.getNewRoleId())).thenAccept(unused -> {
+                        log.debug("Removed role {} from and added role {} to member {} in server {}.", result.getOldRoleId(), result.getNewRoleId(), member.getIdLong(), member.getGuild().getIdLong());
+                    }).exceptionally(throwable -> {
+                        log.warn("Failed to remove role {} from and add role {} to  member {} in server {}.", result.getOldRoleId(), member.getIdLong(), member.getGuild().getIdLong(), throwable);
+                        return null;
+                    });
                 } else {
-                    log.debug("User experience {} does not get a user experience role.", userExperience.getId());
-                    userExperience.setCurrentExperienceRole(null);
+                    if(result.getOldRoleId() != null) {
+                        roleService.removeRoleFromMemberAsync(member, result.getOldRoleId()).thenAccept(unused -> {
+                            log.debug("Removed role {} from member {} in server {}.", result.getOldRoleId(), member.getIdLong(), member.getGuild().getIdLong());
+                        }).exceptionally(throwable -> {
+                            log.warn("Failed to remove role {} from {} member {} in server {}.", result.getOldRoleId(), member.getIdLong(), member.getGuild().getIdLong(), throwable);
+                            return null;
+                        });
+                    }
+                    if(result.getNewRoleId() != null) {
+                        roleService.addRoleToMemberAsync(member, result.getNewRoleId()).thenAccept(unused -> {
+                            log.debug("Added role {} to member {} in server {}.", result.getNewRoleId(), member.getIdLong(), member.getGuild().getIdLong());
+                        }).exceptionally(throwable -> {
+                            log.warn("Failed to add role {} to {} member {} in server {}.", result.getOldRoleId(), member.getIdLong(), member.getGuild().getIdLong(), throwable);
+                            return null;
+                        });
+                    }
                 }
             }
-        });
+        } else {
+            log.debug("Experience gain was disabled. User did not gain any experience.");
+        }
     }
 
     @Override
@@ -488,29 +429,6 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
         return userExperience;
     }
 
-    @Override
-    public CompletableFutureList<RoleCalculationResult> executeActionOnUserExperiencesWithFeedBack(List<AUserExperience> experiences, AChannel channel, Function<AUserExperience, CompletableFuture<RoleCalculationResult>> toExecute) {
-        List<CompletableFuture<RoleCalculationResult>> futures = new ArrayList<>();
-        Long serverId = channel.getServer().getId();
-        MessageToSend status = getUserSyncStatusUpdateModel(0, experiences.size(), serverId);
-        Message statusMessage = messageService.createStatusMessage(status, channel).join();
-        int interval = Math.min(Math.max(experiences.size() / 10, 1), 100);
-        for (int i = 0; i < experiences.size(); i++) {
-            if((i % interval) == 1) {
-                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);
-            }
-            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);
-
-        return new CompletableFutureList<>(futures);
-    }
-
     @Override
     public void disableExperienceForUser(AUserInAServer userInAServer) {
         log.info("Disabling experience gain for user {} in server {}.", userInAServer.getUserReference().getId(), userInAServer.getServerReference().getId());
@@ -525,6 +443,13 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
         userExperience.setExperienceGainDisabled(false);
     }
 
+    @Override
+    public void setLevelUpNotification(AUserInAServer aUserInAServer, Boolean newValue) {
+        Optional<AUserExperience> aUserExperienceOptional = userExperienceManagementService.findByUserInServerIdOptional(aUserInAServer.getUserInServerId());
+        AUserExperience aUserExperience = aUserExperienceOptional.orElseGet(() -> userExperienceManagementService.createUserInServer(aUserInAServer));
+        aUserExperience.setLevelUpNotification(newValue);
+    }
+
     /**
      * Renders a {@link MessageToSend messageToSend} to be used as a status message for the ongoing user synchronization
      * @param current The amount of users which have been synced
@@ -537,15 +462,6 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
         return templateService.renderEmbedTemplate("user_sync_status_message", statusModel, serverId);
     }
 
-    @Override
-    public CompletableFuture<RoleCalculationResult> syncForSingleUser(AUserExperience userExperience) {
-        AUserInAServer user = userExperience.getUser();
-        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());
-    }
-
     @Override
     public LeaderBoard findLeaderBoardData(AServer server, Integer page) {
         if(page <= 0) {

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

@@ -57,9 +57,14 @@ public class ExperienceLevelServiceBean implements ExperienceLevelService {
 
     @Override
     public Long calculateExperienceToNextLevel(Integer level, Long currentExperience) {
-        AExperienceLevel nextLevel = experienceLevelManagementService.getLevelOptional(level + 1)
-                .orElseThrow(() -> new AbstractoRunTimeException(String.format("Could not find level %s", level)));
+        AExperienceLevel nextLevel = calculateNextLevel(level);
         return nextLevel.getExperienceNeeded() - currentExperience;
     }
 
+    @Override
+    public AExperienceLevel calculateNextLevel(Integer level) {
+        return experienceLevelManagementService.getLevelOptional(level + 1)
+                .orElseThrow(() -> new AbstractoRunTimeException(String.format("Could not find level %s", level)));
+    }
+
 }

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

@@ -1,27 +1,29 @@
 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.MessageService;
 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;
-import dev.sheldan.abstracto.experience.model.RoleCalculationResult;
+import dev.sheldan.abstracto.core.templating.model.MessageToSend;
+import dev.sheldan.abstracto.core.templating.service.TemplateService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
 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.model.template.UserSyncStatusModel;
 import dev.sheldan.abstracto.experience.service.management.ExperienceLevelManagementService;
 import dev.sheldan.abstracto.experience.service.management.ExperienceRoleManagementService;
 import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.entities.Role;
+import net.dv8tion.jda.api.entities.channel.middleman.GuildMessageChannel;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
-import org.springframework.transaction.annotation.Transactional;
 
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
 
 @Component
@@ -34,89 +36,46 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
     @Autowired
     private ExperienceLevelManagementService experienceLevelService;
 
-    @Autowired
-    private AUserExperienceService userExperienceService;
-
-    @Autowired
-    private ExperienceRoleServiceBean self;
-
     @Autowired
     private RoleManagementService roleManagementService;
 
-    @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}
-     * @param role The {@link ARole} to set the level to
-     * @param level The level the {@link ARole} should be awarded at
-     */
+    @Autowired
+    private TemplateService templateService;
+
+    @Autowired
+    private MessageService messageService;
+
     @Override
-    public CompletableFuture<Void> setRoleToLevel(Role role, Integer level, Long channelId) {
-        Long roleId = role.getIdLong();
-        ARole aRoleToSet = roleManagementService.findRole(roleId);
+    public CompletableFuture<Void> setRoleToLevel(Role role, Integer level, GuildMessageChannel messageChannel) {
+        ARole aRoleToSet = roleManagementService.findRole(role.getIdLong());
         List<AExperienceRole> experienceRoles = getExperienceRolesAtLevel(level, aRoleToSet.getServer());
-        List<ARole> rolesToUnset = experienceRoles.stream().map(AExperienceRole::getRole).collect(Collectors.toList());
+        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;
+        experienceRoleManagementService.setLevelToRole(experienceLevel, aRoleToSet);
+        if(!rolesToUnset.isEmpty()) {
+            return unsetRoles(rolesToUnset, messageChannel);
+        } else {
+            return CompletableFuture.completedFuture(null);
+        }
     }
 
-    @Transactional
-     public void deleteExperienceRoleViaId(Long newlyCreatedExperienceRoleId) {
-        AExperienceRole reLoadedRole = experienceRoleManagementService.getExperienceRoleById(newlyCreatedExperienceRoleId);
-        experienceRoleManagementService.unsetRole(reLoadedRole);
-    }
-
-    /**
-     * 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
-     */
-    @Transactional
-    public void unsetRoleInDb(Integer level, Long roleId) {
-        log.info("Unsetting role {} from level {}.", roleId, level);
-        AExperienceLevel experienceLevel = experienceLevelService.getLevelOptional(level).orElseThrow(() -> new IllegalArgumentException(String.format("Could not find level %s", level)));
-        ARole loadedRole = roleManagementService.findRole(roleId);
-        experienceRoleManagementService.removeAllRoleAssignmentsForLevelInServerExceptRole(experienceLevel, loadedRole.getServer(), loadedRole);
-        experienceRoleManagementService.setLevelToRole(experienceLevel, loadedRole);
-    }
-
-    /**
-     * Deletes the {@link AExperienceRole} and recalculates the experience for all users which currently had the associated
-     * {@link net.dv8tion.jda.api.entities.Role}.
-     * @param role The {@link ARole} to remove from the {@link dev.sheldan.abstracto.experience.model.database.AExperienceRole}
-     *             configuration
-     */
     @Override
-    public CompletableFuture<Void> unsetRoles(ARole role, Long feedbackChannelId) {
-        return unsetRoles(Arrays.asList(role), feedbackChannelId);
+    public CompletableFuture<Void> unsetRoles(ARole role, GuildMessageChannel messageChannel) {
+        return unsetRoles(Arrays.asList(role), messageChannel);
     }
 
     @Override
@@ -125,64 +84,56 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
         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);
+    public CompletableFuture<Void> unsetRoles(List<ARole> rolesToUnset, GuildMessageChannel messageChannel) {
+        List<AExperienceRole> rolesInServer = experienceRoleManagementService.getRolesInServer(rolesToUnset);
+        Integer totalCount = 0;
+        for (AExperienceRole aExperienceRole : rolesInServer) {
+            totalCount += aExperienceRole.getUsers().size();
         }
-        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());
+        AtomicInteger totalCountAtomic = new AtomicInteger(totalCount);
+        long serverId = messageChannel.getGuild().getIdLong();
+        MessageToSend status = getUserSyncStatusUpdateModel(0, totalCount, serverId);
+        Message statusMessage = messageService.createStatusMessage(status, messageChannel).join();
+        AtomicInteger atomicInteger = new AtomicInteger();
+        List<CompletableFuture<Void>> futures = new ArrayList<>();
+        rolesInServer.forEach(experienceRole -> {
+            experienceRole.getUsers().forEach(aUserExperience -> {
+                futures.add(roleService.removeRoleFromUserAsync(aUserExperience.getUser(), experienceRole.getRole()).thenAccept(unused -> {
+                    atomicInteger.set(atomicInteger.get() + 1);
+                    log.debug("Finished synchronizing {} users.", atomicInteger.get());
+                    if(atomicInteger.get() % 50 == 0) {
+                        log.info("Notifying for {} current users with synchronize.", atomicInteger.get());
+                        MessageToSend newStatus = getUserSyncStatusUpdateModel(atomicInteger.get(), totalCountAtomic.get(), serverId);
+                        messageService.updateStatusMessage(messageChannel, statusMessage.getIdLong(), newStatus);
+                    }
+                }));
+            });
+        });
+        CompletableFuture<Void> returningFuture = new CompletableFuture<>();
+        experienceRoleManagementService.unsetRoles(rolesInServer);
+        FutureUtils.toSingleFutureGeneric(futures).whenComplete((unused, throwable) -> {
+            MessageToSend newStatus = getUserSyncStatusUpdateModel(atomicInteger.get(), totalCountAtomic.get(), serverId);
+            messageService.updateStatusMessage(messageChannel, statusMessage.getIdLong(), newStatus);
+            if(throwable != null) {
+                log.warn("Failed to unset role in server {}.", serverId, throwable);
             }
+            returningFuture.complete(null);
         });
-        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));
+        return returningFuture;
     }
 
-    /**
-     * Stores the changed experience roles for all of the {@link AUserExperience userExperiences} which are referenced in the list of
-     * {@link RoleCalculationResult results}. This is only executed after a role is being "unset", which means, we also
-     * 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 roleIds The IDs of the {@link AExperienceRole experienceRoles} which were removed from the experience roles
-     */
-    @Transactional
-    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());
+    private MessageToSend getUserSyncStatusUpdateModel(Integer current, Integer total, Long serverId) {
+        UserSyncStatusModel statusModel = UserSyncStatusModel
+                .builder()
+                .currentCount(current)
+                .totalUserCount(total)
+                .build();
+        return templateService.renderEmbedTemplate("user_sync_status_message", statusModel, serverId);
     }
 
+
     @Override
     public AExperienceRole calculateRole(List<AExperienceRole> roles, Integer currentLevel) {
         if(roles == null || roles.isEmpty()) {

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

@@ -1,12 +1,9 @@
 package dev.sheldan.abstracto.experience.service;
 
-import dev.sheldan.abstracto.core.metric.service.CounterMetric;
-import dev.sheldan.abstracto.core.metric.service.MetricService;
-import dev.sheldan.abstracto.experience.model.ServerExperience;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
-import javax.annotation.PostConstruct;
+import java.time.Instant;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -20,18 +17,9 @@ import java.util.concurrent.locks.ReentrantLock;
 @Component
 public class RunTimeExperienceService {
 
-    @Autowired
-    private MetricService metricService;
-
-    public static final String EXPERIENCE_RUNTIME_STORAGE = "experience.runtime.storage";
-    private static final CounterMetric EXPERIENCE_RUNTIME_STORAGE_METRIC = CounterMetric
-            .builder()
-            .name(EXPERIENCE_RUNTIME_STORAGE)
-            .build();
-
-    private Map<Long, List<ServerExperience>> runtimeExperience = new HashMap<>();
+    private Map<Long,Map<Long, Instant>> runtimeExperience = new HashMap<>();
     private static final Lock lock = new ReentrantLock();
-    public Map<Long, List<ServerExperience>> getRuntimeExperience() {
+    public Map<Long, Map<Long, Instant>> getRuntimeExperience() {
         return runtimeExperience;
     }
 
@@ -49,12 +37,16 @@ public class RunTimeExperienceService {
         lock.unlock();
     }
 
-    @PostConstruct
-    public void postConstruct() {
-        metricService.registerGauge(EXPERIENCE_RUNTIME_STORAGE_METRIC, runtimeExperience, serverList -> serverList.values().stream()
-                        .mapToInt(minuteEntry -> minuteEntry.stream()
-                        .mapToInt(individualServerList -> individualServerList.getUserInServerIds().size()).sum()).sum(),
-                "Number of entries in runtime experience storage");
+    public void cleanupRunTimeStorage() {
+        Instant now = Instant.now();
+        runtimeExperience.forEach((serverId, userInstantMap) -> {
+            List<Long> userIdsToRemove = new ArrayList<>();
+            userInstantMap.forEach((userId, instant) -> {
+                if(instant.isBefore(now)) {
+                    userIdsToRemove.add(userId);
+                }
+            });
+            userIdsToRemove.forEach(userInstantMap::remove);
+        });
     }
-
 }

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

@@ -3,7 +3,6 @@ package dev.sheldan.abstracto.experience.service.management;
 import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.models.database.AServer;
-import dev.sheldan.abstracto.core.service.management.RoleManagementService;
 import dev.sheldan.abstracto.experience.model.database.AExperienceLevel;
 import dev.sheldan.abstracto.experience.model.database.AExperienceRole;
 import dev.sheldan.abstracto.experience.repository.ExperienceRoleRepository;
@@ -13,6 +12,7 @@ import org.springframework.stereotype.Component;
 
 import java.util.List;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 @Component
 @Slf4j
@@ -22,7 +22,7 @@ public class ExperienceRoleManagementServiceBean implements ExperienceRoleManage
     private ExperienceRoleRepository experienceRoleRepository;
 
     @Autowired
-    private RoleManagementService roleManagementService;
+    private UserExperienceManagementService userExperienceManagementService;
 
     /**
      * Removes *all* assignments of roles for the given level
@@ -46,12 +46,30 @@ public class ExperienceRoleManagementServiceBean implements ExperienceRoleManage
         experienceRoleRepository.delete(role);
     }
 
+    @Override
+    public void unsetRoles(List<AExperienceRole> roles) {
+        log.info("Deleting {} roles.", roles.size());
+        roles.forEach(experienceRole -> {
+            userExperienceManagementService.removeExperienceRoleFromUsers(experienceRole);
+        });
+        experienceRoleRepository.deleteAll(roles);
+    }
+
     @Override
     public AExperienceRole getRoleInServer(ARole role) {
         // TODO throw different exception
         return this.getRoleInServerOptional(role).orElseThrow(AbstractoRunTimeException::new);
     }
 
+    @Override
+    public List<AExperienceRole> getRolesInServer(List<ARole> roles) {
+        List<Long> roleIds = roles
+                .stream()
+                .map(ARole::getId)
+                .collect(Collectors.toList());
+        return experienceRoleRepository.findByRole_IdIn(roleIds);
+    }
+
     @Override
     public Optional<AExperienceRole> getRoleInServerOptional(ARole role) {
         return experienceRoleRepository.findByRole(role);

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

@@ -5,6 +5,7 @@ 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.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.database.LeaderBoardEntryResult;
 import dev.sheldan.abstracto.experience.repository.UserExperienceRepository;
@@ -32,6 +33,11 @@ public class UserExperienceManagementServiceBean implements UserExperienceManage
         return byId.orElseGet(() -> createUserInServer(aUserInAServer));
     }
 
+    @Override
+    public void removeExperienceRoleFromUsers(AExperienceRole experienceRole) {
+        repository.removeExperienceRoleFromUsers(experienceRole.getId());
+    }
+
     @Override
     public Optional<AUserExperience> findByUserInServerIdOptional(Long userInServerId) {
        return repository.findById(userInServerId);
@@ -52,6 +58,7 @@ public class UserExperienceManagementServiceBean implements UserExperienceManage
                 .messageCount(0L)
                 .server(aUserInAServer.getServerReference())
                 .experienceGainDisabled(false)
+                .levelUpNotification(true)
                 .user(aUserInAServer)
                 .id(aUserInAServer.getUserInServerId())
                 .currentLevel(startingLevel)