Sheldan/abstracto
1
0
Fork 0
mirror of https://github.com/Sheldan/abstracto.git synced 2026-04-07 01:30:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

[AB-302] refactoring assignable roles to use buttons instead of reactions

Browse Source 
moved button related services to component service instead of message service
adding component type to component payload
renamed async role service methods
ignoring bot reactions in starboard
fixing rank not showing correct experience to next level for other members
This commit is contained in:
Sheldan
2021-07-09 02:00:33 +02:00
parent c08134a150
commit 7e7591a4b3
117 changed files with 1886 additions and 2470 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -81,16 +81,16 @@ public class Rank extends AbstractConditionableCommand {
.member(parameter)
.build();
return future.thenCompose(leaderBoardEntryModel ->
self.renderAndSendRank(commandContext, rankModel, leaderBoardEntryModel.get(0))
self.renderAndSendRank(commandContext, parameter, rankModel, leaderBoardEntryModel.get(0))
).thenApply(result -> CommandResult.fromIgnored());
}
@Transactional
public CompletableFuture<Void> renderAndSendRank(CommandContext commandContext, RankModel rankModel, LeaderBoardEntryModel leaderBoardEntryModel) {
public CompletableFuture<Void> renderAndSendRank(CommandContext commandContext, Member toRender, RankModel rankModel, LeaderBoardEntryModel leaderBoardEntryModel) {
rankModel.setRankUser(leaderBoardEntryModel);
AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(commandContext.getAuthor());
AUserInAServer aUserInAServer = userInServerManagementService.loadOrCreateUser(toRender);
AUserExperience experienceObj = userExperienceManagementService.findUserInServer(aUserInAServer);
log.info("Rendering rank for user {} in server {}.", commandContext.getAuthor().getId(), commandContext.getGuild().getId());
log.info("Rendering rank for user {} in server {}.", toRender.getId(), commandContext.getGuild().getId());
rankModel.setExperienceToNextLevel(experienceLevelService.calculateExperienceToNextLevel(experienceObj.getCurrentLevel().getLevel(), experienceObj.getExperience()));
MessageToSend messageToSend = templateService.renderEmbedTemplate(RANK_POST_EMBED_TEMPLATE, rankModel, commandContext.getGuild().getIdLong());
return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()));

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

@@ -275,7 +275,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
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.addRoleToUserFuture(aUserInAServer, role.getRole()).thenApply(aVoid -> RoleCalculationResult
return roleService.addRoleToUserAsync(aUserInAServer, role.getRole()).thenApply(aVoid -> RoleCalculationResult
.builder()
.experienceRoleId(experienceRoleId)
.userInServerId(userInServerId)
@@ -352,7 +352,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
user.getUserReference().getId(), serverId);
// if the user has a experience role currently, remove it
if(!currentlyHasNoExperienceRole && !userExperience.getCurrentExperienceRole().getRole().getDeleted()){
return roleService.removeRoleFromUserFuture(user, userExperience.getCurrentExperienceRole().getRole())
return roleService.removeRoleFromUserAsync(user, userExperience.getCurrentExperienceRole().getRole())
.thenApply(returnNullRole);
}
return CompletableFuture.completedFuture(returnNullRole.apply(null));
@@ -389,7 +389,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
CompletableFuture<Void> addRoleFuture;
if(!userHasRoleAlready) {
log.info("User {} in server {} gets a new role {} because of experience.", userId, serverId, roleId);
addRoleFuture = roleService.addRoleToMemberFuture(member, roleId);
addRoleFuture = roleService.addRoleToMemberAsync(member, roleId);
} else {
addRoleFuture = CompletableFuture.completedFuture(null);
}

23
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/condition/HasLevelCondition.java
View File

@@ -13,7 +13,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
/**
@@ -36,7 +36,7 @@ public class HasLevelCondition implements SystemCondition {
@Override
public boolean checkCondition(ConditionContextInstance conditionContext) {
HashMap<String, Object> parameters = conditionContext.getParameters();
Map<String, Object> parameters = conditionContext.getParameters();
Long userInServerId = (Long) parameters.get(USER_IN_SERVER_ID_VARIABLE_KEY);
Integer level = (Integer) parameters.get(LEVEL_VARIABLE);
log.info("Evaluating has level condition.");
@@ -48,7 +48,7 @@ public class HasLevelCondition implements SystemCondition {
AUserExperience user = userExperienceManagementService.findUserInServer(userInServer);
return user.getCurrentLevel() != null && user.getCurrentLevel().getLevel() >= level;
}
log.info("No user experience object was found. Evaluating to false.");
log.info("No user in server object was found. Evaluating to false.");
return false;
}
@@ -60,8 +60,19 @@ public class HasLevelCondition implements SystemCondition {
@Override
public ConditionContext getExpectedContext() {
ConditionContextVariable userIdVariable = ConditionContextVariable.builder().name(USER_IN_SERVER_ID_VARIABLE_KEY).type(Long.class).build();
ConditionContextVariable levelVariable = ConditionContextVariable.builder().name(LEVEL_VARIABLE).type(Integer.class).build();
return ConditionContext.builder().requiredVariables(Arrays.asList(userIdVariable, levelVariable)).build();
ConditionContextVariable userIdVariable = ConditionContextVariable
.builder()
.name(USER_IN_SERVER_ID_VARIABLE_KEY)
.type(Long.class)
.build();
ConditionContextVariable levelVariable = ConditionContextVariable
.builder()
.name(LEVEL_VARIABLE)
.type(Integer.class)
.build();
return ConditionContext
.builder()
.requiredVariables(Arrays.asList(userIdVariable, levelVariable))
.build();
}
}

5
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/command/RankTest.java
View File

@@ -18,6 +18,7 @@ import dev.sheldan.abstracto.experience.service.ExperienceLevelService;
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 net.dv8tion.jda.api.entities.Member;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
@@ -75,7 +76,7 @@ public class RankTest {
LeaderBoardEntryModel leaderBoardEntryModel = Mockito.mock(LeaderBoardEntryModel.class);
when(context.getAuthor().getGuild()).thenReturn(context.getGuild());
when(converter.fromLeaderBoardEntry(Arrays.asList(leaderBoardEntry))).thenReturn(CompletableFuture.completedFuture(Arrays.asList(leaderBoardEntryModel)));
when(self.renderAndSendRank(eq(context), any(RankModel.class), eq(leaderBoardEntryModel))).thenReturn(CompletableFuture.completedFuture(null));
when(self.renderAndSendRank(eq(context), any(Member.class), any(RankModel.class), eq(leaderBoardEntryModel))).thenReturn(CompletableFuture.completedFuture(null));
CompletableFuture<CommandResult> result = testUnit.executeAsync(context);
CommandTestUtilities.checkSuccessfulCompletionAsync(result);
}
@@ -99,7 +100,7 @@ public class RankTest {
MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
when(templateService.renderEmbedTemplate(RANK_POST_EMBED_TEMPLATE, rankModel, SERVER_ID)).thenReturn(messageToSend);
when(channelService.sendMessageToSendToChannel(messageToSend, context.getChannel())).thenReturn(Arrays.asList(CompletableFuture.completedFuture(null)));
testUnit.renderAndSendRank(context, rankModel, leaderBoardEntryModel).join();
testUnit.renderAndSendRank(context, context.getAuthor(), rankModel, leaderBoardEntryModel).join();
}
@Test

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

@@ -265,7 +265,7 @@ public class AUserExperienceServiceBeanTest {
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
when(userExperience.getCurrentExperienceRole()).thenReturn(experienceRole1);
when(userExperience.getUser()).thenReturn(aUserInAServer);
when(roleService.removeRoleFromUserFuture(aUserInAServer, aRole1)).thenReturn(CompletableFuture.completedFuture(null));
when(roleService.removeRoleFromUserAsync(aUserInAServer, aRole1)).thenReturn(CompletableFuture.completedFuture(null));
ArrayList<ExperienceGainResult> experienceResults = new ArrayList<>();
ArrayList<CompletableFuture<RoleCalculationResult>> roleCalculationResults = new ArrayList<>();
List<CompletableFuture<Member>> memberFutures = Arrays.asList(CompletableFuture.completedFuture(firstMember));
@@ -277,8 +277,8 @@ public class AUserExperienceServiceBeanTest {
RoleCalculationResult roleCalcResult = roleCalculationResults.get(0).join();
Assert.assertNull(roleCalcResult.getExperienceRoleId());
Assert.assertEquals(USER_IN_SERVER_ID, roleCalcResult.getUserInServerId());
verify(roleService, times(1)).removeRoleFromUserFuture(aUserInAServer, aRole1);
verify(roleService, times(0)).addRoleToUserFuture(any(AUserInAServer.class), any());
verify(roleService, times(1)).removeRoleFromUserAsync(aUserInAServer, aRole1);
verify(roleService, times(0)).addRoleToUserAsync(any(AUserInAServer.class), any());
}
@Test
@@ -302,7 +302,7 @@ public class AUserExperienceServiceBeanTest {
ArrayList<CompletableFuture<RoleCalculationResult>> roleCalculationResults = new ArrayList<>();
List<CompletableFuture<Member>> memberFutures = Arrays.asList(CompletableFuture.completedFuture(firstMember));
testUnit.updateFoundMembers(memberFutures, SERVER_ID, experienceResults, roleCalculationResults);
verify(roleService, times(0)).addRoleToUser(any(AUserInAServer.class), any(ARole.class));
verify(roleService, times(0)).addRoleToMember(any(AUserInAServer.class), any(ARole.class));
verify(roleService, times(0)).removeRoleFromUser(any(AUserInAServer.class), any(ARole.class));
}
@@ -328,7 +328,7 @@ public class AUserExperienceServiceBeanTest {
ArrayList<CompletableFuture<RoleCalculationResult>> roleCalculationResults = new ArrayList<>();
List<CompletableFuture<Member>> memberFutures = Arrays.asList(CompletableFuture.completedFuture(firstMember));
testUnit.updateFoundMembers(memberFutures, SERVER_ID, experienceResults, roleCalculationResults);
verify(roleService, times(0)).addRoleToUser(any(AUserInAServer.class), any(ARole.class));
verify(roleService, times(0)).addRoleToMember(any(AUserInAServer.class), any(ARole.class));
verify(roleService, times(0)).removeRoleFromUser(any(AUserInAServer.class), any(ARole.class));
}
@@ -347,15 +347,15 @@ public class AUserExperienceServiceBeanTest {
when(aRole1.getId()).thenReturn(ROLE_ID);
setupTwoExperienceRoles();
when(roleService.memberHasRole(firstMember, ROLE_ID)).thenReturn(false);
when(roleService.addRoleToMemberFuture(firstMember, ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
when(roleService.addRoleToMemberAsync(firstMember, ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
when(roleService.addRoleToMemberFuture(firstMember, ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
when(roleService.addRoleToMemberAsync(firstMember, ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
ArrayList<ExperienceGainResult> experienceResults = new ArrayList<>();
ArrayList<CompletableFuture<RoleCalculationResult>> roleCalculationResults = new ArrayList<>();
List<CompletableFuture<Member>> memberFutures = Arrays.asList(CompletableFuture.completedFuture(firstMember));
testUnit.updateFoundMembers(memberFutures, SERVER_ID, experienceResults, roleCalculationResults);
verify(roleService, times(0)).addRoleToUserFuture(any(AUserInAServer.class), any(ARole.class));
verify(roleService, times(0)).removeRoleFromUserFuture(any(AUserInAServer.class), any());
verify(roleService, times(0)).addRoleToUserAsync(any(AUserInAServer.class), any(ARole.class));
verify(roleService, times(0)).removeRoleFromUserAsync(any(AUserInAServer.class), any());
}
@Test
@@ -374,8 +374,8 @@ public class AUserExperienceServiceBeanTest {
ArrayList<CompletableFuture<RoleCalculationResult>> roleCalculationResults = new ArrayList<>();
List<CompletableFuture<Member>> memberFutures = Arrays.asList(CompletableFuture.completedFuture(firstMember));
testUnit.updateFoundMembers(memberFutures, SERVER_ID, experienceResults, roleCalculationResults);
verify(roleService, times(0)).removeRoleFromUserFuture(any(AUserInAServer.class), any());
verify(roleService, times(0)).addRoleToUserFuture(any(AUserInAServer.class), any());
verify(roleService, times(0)).removeRoleFromUserAsync(any(AUserInAServer.class), any());
verify(roleService, times(0)).addRoleToUserAsync(any(AUserInAServer.class), any());
}
@Test
@@ -392,14 +392,14 @@ public class AUserExperienceServiceBeanTest {
setExperienceRoleLevels();
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(null);
when(roleService.removeRoleFromUserFuture(eq(aUserInAServer), any())).thenReturn(CompletableFuture.completedFuture(null));
when(roleService.removeRoleFromUserAsync(eq(aUserInAServer), any())).thenReturn(CompletableFuture.completedFuture(null));
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
ArrayList<ExperienceGainResult> experienceResults = new ArrayList<>();
ArrayList<CompletableFuture<RoleCalculationResult>> roleCalculationResults = new ArrayList<>();
List<CompletableFuture<Member>> memberFutures = Arrays.asList(CompletableFuture.completedFuture(firstMember));
testUnit.updateFoundMembers(memberFutures, SERVER_ID, experienceResults, roleCalculationResults);
verify(roleService, times(0)).addRoleToUserFuture(eq(aUserInAServer), any());
verify(roleService, times(1)).removeRoleFromUserFuture(eq(aUserInAServer), any());
verify(roleService, times(0)).addRoleToUserAsync(eq(aUserInAServer), any());
verify(roleService, times(1)).removeRoleFromUserAsync(eq(aUserInAServer), any());
}
@Test
@@ -419,8 +419,8 @@ public class AUserExperienceServiceBeanTest {
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
testUnit.updateFoundMembers(memberFutures, SERVER_ID, experienceResults, roleCalculationResults);
verify(roleService, times(0)).removeRoleFromUserFuture(eq(aUserInAServer), any());
verify(roleService, times(0)).addRoleToUserFuture(eq(aUserInAServer), any());
verify(roleService, times(0)).removeRoleFromUserAsync(eq(aUserInAServer), any());
verify(roleService, times(0)).addRoleToUserAsync(eq(aUserInAServer), any());
}
@Test
@@ -440,7 +440,7 @@ public class AUserExperienceServiceBeanTest {
List<CompletableFuture<Member>> memberFutures = Arrays.asList(CompletableFuture.completedFuture(firstMember));
testUnit.updateFoundMembers(memberFutures, SERVER_ID, experienceResults, roleCalculationResults);
verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, aRole1);
verify(roleService, times(0)).addRoleToUser(eq(aUserInAServer), any(ARole.class));
verify(roleService, times(0)).addRoleToMember(eq(aUserInAServer), any(ARole.class));
}
@Test
@@ -466,7 +466,7 @@ public class AUserExperienceServiceBeanTest {
List<CompletableFuture<Member>> memberFutures = Arrays.asList(CompletableFuture.completedFuture(firstMember));
testUnit.updateFoundMembers(memberFutures, SERVER_ID, experienceResults, roleCalculationResults);
verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, aRole1);
verify(roleService, times(0)).addRoleToUser(eq(aUserInAServer), any(ARole.class));
verify(roleService, times(0)).addRoleToMember(eq(aUserInAServer), any(ARole.class));
}
@Test
@@ -487,7 +487,7 @@ public class AUserExperienceServiceBeanTest {
when(experienceRole2.getLevel()).thenReturn(level1);
when(experienceRoleService.calculateRole(experienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
when(memberService.getMemberInServerAsync(userExperience.getUser())).thenReturn(CompletableFuture.completedFuture(firstMember));
when(roleService.addRoleToMemberFuture(firstMember, ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
when(roleService.addRoleToMemberAsync(firstMember, ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
CompletableFuture<RoleCalculationResult> calculationFuture = testUnit.syncForSingleUser(userExperience);
RoleCalculationResult result = calculationFuture.join();
Assert.assertEquals(ROLE_ID, result.getExperienceRoleId());
@@ -504,7 +504,7 @@ public class AUserExperienceServiceBeanTest {
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
when(experienceRoleService.calculateRole(experienceRoles, userExperience.getLevelOrDefault())).thenReturn(null);
when(roleService.removeRoleFromUserFuture(aUserInAServer, aRole1)).thenReturn(CompletableFuture.completedFuture(null));
when(roleService.removeRoleFromUserAsync(aUserInAServer, aRole1)).thenReturn(CompletableFuture.completedFuture(null));
when(experienceRole1.getLevel()).thenReturn(level0);
when(experienceRole2.getLevel()).thenReturn(level1);
CompletableFuture<RoleCalculationResult> calculationFuture = testUnit.syncForSingleUser(userExperience);
@@ -562,7 +562,7 @@ public class AUserExperienceServiceBeanTest {
when(experienceRole2.getLevel()).thenReturn(level1);
when(roleService.memberHasRole(firstMember, SECOND_ROLE_ID)).thenReturn(false);
when(roleService.removeRoleFromMemberAsync(firstMember, ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
when(roleService.addRoleToMemberFuture(firstMember, SECOND_ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
when(roleService.addRoleToMemberAsync(firstMember, SECOND_ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
CompletableFuture<RoleCalculationResult> calculationFuture = testUnit.syncForSingleUser(userExperience);
RoleCalculationResult result = calculationFuture.join();
Assert.assertEquals(SECOND_ROLE_ID, result.getExperienceRoleId());
@@ -642,14 +642,14 @@ public class AUserExperienceServiceBeanTest {
when(roleService.memberHasRole(firstMember, ROLE_ID)).thenReturn(true);
when(roleService.memberHasRole(secondMember, SECOND_ROLE_ID)).thenReturn(true);
when(roleService.removeRoleFromMemberAsync(firstMember, ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
when(roleService.addRoleToMemberFuture(firstMember,SECOND_ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
when(roleService.addRoleToMemberAsync(firstMember,SECOND_ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
List<AUserExperience> experiences = Arrays.asList(userExperience, userExperience2);
when(userExperienceManagementService.loadAllUsers(server)).thenReturn(experiences);
when(experienceRole1.getLevel()).thenReturn(level0);
when(experienceRole2.getLevel()).thenReturn(level1);
List<CompletableFuture<RoleCalculationResult>> calculationFutures = testUnit.syncUserRoles(server);
verify(roleService, times(0)).removeRoleFromMemberAsync(secondMember, ROLE_ID);
verify(roleService, times(0)).addRoleToMemberFuture(secondMember, SECOND_ROLE_ID);
verify(roleService, times(0)).addRoleToMemberAsync(secondMember, SECOND_ROLE_ID);
RoleCalculationResult firstResult = calculationFutures.get(0).join();
Assert.assertEquals(SECOND_ROLE_ID, firstResult.getExperienceRoleId());
RoleCalculationResult secondResult = calculationFutures.get(1).join();