[AB-139] changing the places at which there might be an uncached member object

fixing integer validator fixing syncing roles not working if the role did not change in the database fixing warn id being flipped fixing star stats model
2026-04-14 03:45:57 +00:00 · 2020-10-11 22:04:18 +02:00
parent 1d3c414d6b
commit 36d11371cb
105 changed files with 1762 additions and 1086 deletions
--- a/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/LeaderBoardCommand.java
+++ b/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/LeaderBoardCommand.java
@@ -16,6 +16,7 @@ import dev.sheldan.abstracto.experience.config.features.ExperienceFeature;
 import dev.sheldan.abstracto.experience.converter.LeaderBoardModelConverter;
 import dev.sheldan.abstracto.experience.models.LeaderBoard;
 import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
+import dev.sheldan.abstracto.experience.models.templates.LeaderBoardEntryModel;
 import dev.sheldan.abstracto.experience.models.templates.LeaderBoardModel;
 import dev.sheldan.abstracto.experience.service.AUserExperienceService;
 import dev.sheldan.abstracto.templating.model.MessageToSend;
@@ -28,6 +29,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;

 /**
 * Shows the experience gain information of the top 10 users in the server, or if a page number is provided as a parameter, only the members which are on this page.
@@ -57,15 +59,22 @@ public class LeaderBoardCommand extends AbstractConditionableCommand {
        // parameter is optional, in case its not present, we default to the 0th page
        Integer page = !parameters.isEmpty() ? (Integer) parameters.get(0) : 1;
        LeaderBoard leaderBoard = userExperienceService.findLeaderBoardData(commandContext.getUserInitiatedContext().getServer(), page);
-        LeaderBoardModel leaderBoardModel = (LeaderBoardModel) ContextConverter.fromCommandContext(commandContext, LeaderBoardModel.class);
-        leaderBoardModel.setUserExperiences(converter.fromLeaderBoard(leaderBoard));
+        LeaderBoardModel leaderBoardModel = (LeaderBoardModel) ContextConverter.slimFromCommandContext(commandContext, LeaderBoardModel.class);
+        List<CompletableFuture<LeaderBoardEntryModel>> futures = new ArrayList<>();
+        List<CompletableFuture<LeaderBoardEntryModel>> completableFutures = converter.fromLeaderBoard(leaderBoard);
+        futures.addAll(completableFutures);
        log.info("Rendering leaderboard for page {} in server {} for user {}.", page, commandContext.getAuthor().getId(), commandContext.getGuild().getId());

        LeaderBoardEntry userRank = userExperienceService.getRankOfUserInServer(commandContext.getUserInitiatedContext().getAUserInAServer());
-        leaderBoardModel.setUserExecuting(converter.fromLeaderBoardEntry(userRank));
-        MessageToSend messageToSend = templateService.renderEmbedTemplate(LEADER_BOARD_POST_EMBED_TEMPLATE, leaderBoardModel);
-        return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
-                .thenApply(aVoid -> CommandResult.fromSuccess());
+        CompletableFuture<LeaderBoardEntryModel> userRankFuture = converter.fromLeaderBoardEntry(userRank);
+        futures.add(userRankFuture);
+        return FutureUtils.toSingleFutureGeneric(futures).thenCompose(aVoid -> {
+            List<LeaderBoardEntryModel> finalModels = completableFutures.stream().map(CompletableFuture::join).collect(Collectors.toList());
+            leaderBoardModel.setUserExperiences(finalModels);
+            leaderBoardModel.setUserExecuting(userRankFuture.join());
+            MessageToSend messageToSend = templateService.renderEmbedTemplate(LEADER_BOARD_POST_EMBED_TEMPLATE, leaderBoardModel);
+            return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()));
+        }).thenApply(aVoid -> CommandResult.fromSuccess());

    }

--- a/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/Rank.java
+++ b/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/Rank.java
@@ -8,20 +8,25 @@ import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.CommandResult;
 import dev.sheldan.abstracto.core.command.execution.ContextConverter;
 import dev.sheldan.abstracto.core.config.FeatureEnum;
+import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 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.experience.config.features.ExperienceFeature;
 import dev.sheldan.abstracto.experience.converter.LeaderBoardModelConverter;
 import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
 import dev.sheldan.abstracto.experience.models.database.AUserExperience;
+import dev.sheldan.abstracto.experience.models.templates.LeaderBoardEntryModel;
 import dev.sheldan.abstracto.experience.models.templates.RankModel;
 import dev.sheldan.abstracto.experience.service.ExperienceLevelService;
 import dev.sheldan.abstracto.experience.service.AUserExperienceService;
+import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
 import dev.sheldan.abstracto.templating.model.MessageToSend;
 import dev.sheldan.abstracto.templating.service.TemplateService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;

 import java.util.ArrayList;
 import java.util.List;
@@ -50,19 +55,35 @@ public class Rank extends AbstractConditionableCommand {
    @Autowired
    private ChannelService channelService;

+    @Autowired
+    private Rank self;
+
+    @Autowired
+    private UserInServerManagementService userInServerManagementService;
+
+    @Autowired
+    private UserExperienceManagementService userExperienceManagementService;

    @Override
    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
        checkParameters(commandContext);
-        RankModel rankModel = (RankModel) ContextConverter.fromCommandContext(commandContext, RankModel.class);
+        RankModel rankModel = (RankModel) ContextConverter.slimFromCommandContext(commandContext, RankModel.class);
        LeaderBoardEntry userRank = userExperienceService.getRankOfUserInServer(commandContext.getUserInitiatedContext().getAUserInAServer());
-        rankModel.setRankUser(converter.fromLeaderBoardEntry(userRank));
-        AUserExperience experienceObj = userRank.getExperience();
+        CompletableFuture<LeaderBoardEntryModel> future = converter.fromLeaderBoardEntry(userRank);
+        return future.thenCompose(leaderBoardEntryModel ->
+            self.renderAndSendRank(commandContext, rankModel, leaderBoardEntryModel)
+        ).thenApply(result -> CommandResult.fromSuccess());
+    }
+
+    @Transactional
+    public CompletableFuture<Void> renderAndSendRank(CommandContext commandContext, RankModel rankModel, LeaderBoardEntryModel leaderBoardEntryModel) {
+        rankModel.setRankUser(leaderBoardEntryModel);
+        AUserInAServer aUserInAServer = userInServerManagementService.loadUser(commandContext.getAuthor());
+        AUserExperience experienceObj = userExperienceManagementService.findUserInServer(aUserInAServer);
        log.info("Rendering rank for user {} in server {}.", commandContext.getAuthor().getId(), commandContext.getGuild().getId());
        rankModel.setExperienceToNextLevel(experienceLevelService.calculateExperienceToNextLevel(experienceObj.getCurrentLevel().getLevel(), experienceObj.getExperience()));
        MessageToSend messageToSend = templateService.renderEmbedTemplate(RANK_POST_EMBED_TEMPLATE, rankModel);
-        return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
-                .thenApply(aVoid -> CommandResult.fromSuccess());
+        return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()));
    }

    @Override
--- a/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/converter/LeaderBoardModelConverter.java
+++ b/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/converter/LeaderBoardModelConverter.java
@@ -12,6 +12,7 @@ import org.springframework.stereotype.Component;

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

 /**
 * Converter used to convert from {@link LeaderBoard} to a list of {@link LeaderBoardEntryModel}
@@ -30,11 +31,11 @@ public class LeaderBoardModelConverter {
     * @return The list of {@link LeaderBoardEntryModel} which contain the fully fledged information provided to the
     * leader board template
     */
-    public List<LeaderBoardEntryModel> fromLeaderBoard(LeaderBoard leaderBoard) {
-        List<LeaderBoardEntryModel> models = new ArrayList<>();
+    public List<CompletableFuture<LeaderBoardEntryModel>> fromLeaderBoard(LeaderBoard leaderBoard) {
+        List<CompletableFuture<LeaderBoardEntryModel>> models = new ArrayList<>();
        log.trace("Converting {} entries to a list of leaderbord entries.", leaderBoard.getEntries().size());
        leaderBoard.getEntries().forEach(leaderBoardEntry -> {
-            LeaderBoardEntryModel entry = fromLeaderBoardEntry(leaderBoardEntry);
+            CompletableFuture<LeaderBoardEntryModel> entry = fromLeaderBoardEntry(leaderBoardEntry);
            models.add(entry);
        });
        return models;
@@ -47,14 +48,15 @@ public class LeaderBoardModelConverter {
     * @return The {@link LeaderBoardEntryModel} accompanied with the {@link Member} reference, might be null, if the
     * user left the guild
     */
-    public LeaderBoardEntryModel fromLeaderBoardEntry(LeaderBoardEntry leaderBoardEntry) {
+    public CompletableFuture<LeaderBoardEntryModel> fromLeaderBoardEntry(LeaderBoardEntry leaderBoardEntry) {
        AUserInAServer entryUser = leaderBoardEntry.getExperience().getUser();
-        Member entryMember = botService.getMemberInServer(entryUser.getServerReference().getId(), entryUser.getUserReference().getId());
-        return LeaderBoardEntryModel
-                .builder()
-                .experience(leaderBoardEntry.getExperience())
-                .member(entryMember).rank(leaderBoardEntry.getRank())
-                .rank(leaderBoardEntry.getRank())
-                .build();
+        return botService.getMemberInServerAsync(entryUser.getServerReference().getId(), entryUser.getUserReference().getId()).thenApply(member ->
+            LeaderBoardEntryModel
+                    .builder()
+                    .experience(leaderBoardEntry.getExperience())
+                    .member(member).rank(leaderBoardEntry.getRank())
+                    .rank(leaderBoardEntry.getRank())
+                    .build()
+        );
    }
 }
--- a/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/AUserExperienceServiceBean.java
+++ b/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/AUserExperienceServiceBean.java
@@ -186,7 +186,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
                AUserInAServer userInAServer = userInServerManagementService.loadUser(userInAServerId);
                gainedExperience = (int) Math.floor(gainedExperience * multiplier);
                Member member = botService.getMemberInServer(userInAServer);
-                if(!roleService.hasAnyOfTheRoles(member, disabledRoles)) {
+                if(member != null && !roleService.hasAnyOfTheRoles(member, disabledRoles)) {
                    log.trace("Handling {}. The user gains {}", userInAServer.getUserReference().getId(), gainedExperience);
                    Optional<AUserExperience> aUserExperienceOptional = userExperienceManagementService.findByUserInServerIdOptional(userInAServerId);
                    if(aUserExperienceOptional.isPresent()) {
@@ -230,7 +230,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
                        futures.add(resultFuture);
                    }
                } else {
-                    log.trace("User {} has a role which makes the user unable to gain experience.", userInAServer.getUserInServerId());
+                    log.trace("User {} has a role which makes the user unable to gain experience or the member could not be found in the server.", userInAServer.getUserInServerId());
                }
            });
        });
@@ -321,43 +321,62 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
                .userInServerId(user.getUserInServerId())
                .experienceRoleId(null)
                .build();
-        if(!botService.isUserInGuild(userExperience.getUser())) {
-            log.trace("User {} is not in server {} anymore. No role calculation done.", userExperience.getUser().getUserInServerId(), userExperience.getUser().getServerReference().getId());
-            return CompletableFuture.completedFuture(returnNullRole.apply(null));
-        }
        Long userInServerId = user.getUserInServerId();
-        log.trace("Updating experience role for user {} in server {}", user.getUserReference().getId(), user.getServerReference().getId());
+        Long serverId = user.getServerReference().getId();
+        log.trace("Updating experience role for user {} in server {}", user.getUserReference().getId(), serverId);
        AExperienceRole role = experienceRoleService.calculateRole(roles, currentLevel);
-        Member member = botService.getMemberInServer(user.getServerReference(), user.getUserReference());
        boolean currentlyHasNoExperienceRole = userExperience.getCurrentExperienceRole() == null;
+        // if calculation results in no role, do not add a role
        if(role == null) {
            log.trace("User {} in server {} does not have an experience role, according to new calculation.",
-                    user.getUserReference().getId(),  user.getServerReference().getId());
+                    user.getUserReference().getId(), serverId);
+            // if the user has a experience role currently, remove it
            if(!currentlyHasNoExperienceRole){
                return roleService.removeRoleFromUserFuture(user, userExperience.getCurrentExperienceRole().getRole())
                        .thenApply(returnNullRole);
            }
            return CompletableFuture.completedFuture(returnNullRole.apply(null));
        }
-        boolean userHasRoleAlready = roleService.memberHasRole(member, role.getRole());
        Long experienceRoleId = role.getId();
-        Function<Void, RoleCalculationResult> fullResult = aVoid -> RoleCalculationResult
-                .builder()
-                .experienceRoleId(experienceRoleId)
-                .userInServerId(userInServerId)
-                .build();
-        if(!userHasRoleAlready && (currentlyHasNoExperienceRole || !role.getRole().getId().equals(userExperience.getCurrentExperienceRole().getRole().getId()))) {
-            log.info("User {} in server {} gets a new role {} because of experience.", user.getUserReference().getId(), user.getServerReference().getId(), role.getRole().getId());
-            CompletableFuture<Void> removalFuture;
-            if(!currentlyHasNoExperienceRole && botService.isUserInGuild(userExperience.getUser())) {
-                removalFuture = roleService.removeRoleFromUserFuture(user, userExperience.getCurrentExperienceRole().getRole());
-            } else {
-                removalFuture = CompletableFuture.completedFuture(null);
+        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 botService.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);
            }
-            CompletableFuture<Void> addRoleFuture = roleService.addRoleToUserFuture(user, role.getRole());
-            return CompletableFuture.allOf(removalFuture, addRoleFuture).thenApply(fullResult);
-        }
-        return CompletableFuture.completedFuture(fullResult.apply(null));
+            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)) {
+                log.info("User {} in server {} gets a new role {} because of experience.", userId, serverId, roleId);
+                CompletableFuture<Void> removalFuture;
+                if(userHasOldRole && rolesChanged) {
+                    removalFuture = roleService.removeRoleFromMemberAsync(member, oldUserExperienceRoleId);
+                } else {
+                    removalFuture = CompletableFuture.completedFuture(null);
+                }
+                CompletableFuture<Void> addRoleFuture;
+                if(!userHasRoleAlready) {
+                    addRoleFuture = roleService.addRoleToMemberFuture(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));
+        });
    }

    /**
@@ -405,7 +424,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
            if(result != null) {
                AUserInAServer user = userInServerManagementService.loadUser(result.getUserInServerId());
                AUserExperience userExperience = userExperienceManagementService.findUserInServer(user);
-                log.trace("Updating experience role for {} in server {} to {}", user.getUserInServerId(), user.getServerReference(), result.getExperienceRoleId());
+                log.trace("Updating experience role for {} in server {} to {}", user.getUserInServerId(), user.getServerReference().getId(), result.getExperienceRoleId());
                if(result.getExperienceRoleId() != null) {
                    log.trace("User experience {} gets new experience role with id {}.", userExperience.getId(), result.getExperienceRoleId());
                    AExperienceRole role = experienceRoleManagementService.getExperienceRoleById(result.getExperienceRoleId());
--- a/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/management/ExperienceRoleManagementServiceBean.java
+++ b/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/management/ExperienceRoleManagementServiceBean.java
@@ -83,7 +83,7 @@ public class ExperienceRoleManagementServiceBean implements ExperienceRoleManage
    public AExperienceRole setLevelToRole(AExperienceLevel level, ARole role) {
        Optional<AExperienceRole> byRoleServerAndRoleOptional = getRoleInServerOptional(role);
        AExperienceRole experienceRole;
-        log.info("Setting role {} in server {} to level {}.", role.getId(), role.getServer().getId(), level);
+        log.info("Setting role {} in server {} to level {}.", role.getId(), role.getServer().getId(), level.getLevel());
        if(byRoleServerAndRoleOptional.isPresent()) {
            log.trace("Role already existed. Updating.");
            experienceRole = byRoleServerAndRoleOptional.get();