mirror of
https://github.com/Sheldan/abstracto.git
synced 2026-01-25 11:22:06 +00:00
[AB-247/AB-252] fixing issue with set experience role failing to consider the correct experience roles
adding levelRoles command ignoring bots from experience gain adding a bit more logging to user experience handling
This commit is contained in:
Sheldan
@@ -0,0 +1,73 @@
|
||||
package dev.sheldan.abstracto.experience.command;
|
||||
|
||||
import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
|
||||
import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
|
||||
import dev.sheldan.abstracto.core.command.config.HelpInfo;
|
||||
import dev.sheldan.abstracto.core.command.config.Parameter;
|
||||
import dev.sheldan.abstracto.core.command.execution.CommandContext;
|
||||
import dev.sheldan.abstracto.core.command.execution.CommandResult;
|
||||
import dev.sheldan.abstracto.core.config.FeatureDefinition;
|
||||
import dev.sheldan.abstracto.core.models.database.AServer;
|
||||
import dev.sheldan.abstracto.core.service.ChannelService;
|
||||
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
|
||||
import dev.sheldan.abstracto.core.utils.FutureUtils;
|
||||
import dev.sheldan.abstracto.experience.config.ExperienceFeatureDefinition;
|
||||
import dev.sheldan.abstracto.experience.model.template.LevelRole;
|
||||
import dev.sheldan.abstracto.experience.model.template.LevelRolesModel;
|
||||
import dev.sheldan.abstracto.experience.service.ExperienceRoleService;
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.stereotype.Component;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Comparator;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
@Component
|
||||
public class LevelRoles extends AbstractConditionableCommand {
|
||||
|
||||
@Autowired
|
||||
private ExperienceRoleService experienceRoleService;
|
||||
|
||||
@Autowired
|
||||
private ServerManagementService serverManagementService;
|
||||
|
||||
@Autowired
|
||||
private ChannelService channelService;
|
||||
|
||||
private static final String LEVEL_ROLES_TEMPLATE_KEY = "levelRoles_response";
|
||||
|
||||
@Override
|
||||
public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
|
||||
AServer server = serverManagementService.loadServer(commandContext.getGuild());
|
||||
List<LevelRole> levelRoles = experienceRoleService.loadLevelRoleConfigForServer(server);
|
||||
levelRoles = levelRoles.stream().sorted(Comparator.comparingInt(LevelRole::getLevel).reversed()).collect(Collectors.toList());
|
||||
LevelRolesModel model = LevelRolesModel
|
||||
.builder()
|
||||
.levelRoles(levelRoles)
|
||||
.build();
|
||||
return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInTextChannelList(LEVEL_ROLES_TEMPLATE_KEY, model, commandContext.getChannel()))
|
||||
.thenApply(unused -> CommandResult.fromSuccess());
|
||||
}
|
||||
|
||||
@Override
|
||||
public CommandConfiguration getConfiguration() {
|
||||
List<Parameter> parameters = new ArrayList<>();
|
||||
HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
|
||||
return CommandConfiguration.builder()
|
||||
.name("levelRoles")
|
||||
.module(ExperienceModuleDefinition.EXPERIENCE)
|
||||
.async(true)
|
||||
.templated(true)
|
||||
.supportsEmbedException(true)
|
||||
.parameters(parameters)
|
||||
.help(helpInfo)
|
||||
.build();
|
||||
}
|
||||
|
||||
@Override
|
||||
public FeatureDefinition getFeature() {
|
||||
return ExperienceFeatureDefinition.EXPERIENCE;
|
||||
}
|
||||
}
|
||||
@@ -10,12 +10,16 @@ import dev.sheldan.abstracto.core.config.FeatureDefinition;
|
||||
import dev.sheldan.abstracto.core.models.database.ARole;
|
||||
import dev.sheldan.abstracto.core.service.management.RoleManagementService;
|
||||
import dev.sheldan.abstracto.experience.config.ExperienceFeatureDefinition;
|
||||
import dev.sheldan.abstracto.experience.exception.ExperienceRoleNotFoundException;
|
||||
import dev.sheldan.abstracto.experience.model.database.AExperienceRole;
|
||||
import dev.sheldan.abstracto.experience.service.ExperienceRoleService;
|
||||
import dev.sheldan.abstracto.experience.service.management.ExperienceRoleManagementService;
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.stereotype.Component;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
|
||||
/**
|
||||
@@ -31,13 +35,20 @@ public class UnSetExpRole extends AbstractConditionableCommand {
|
||||
@Autowired
|
||||
private RoleManagementService roleManagementService;
|
||||
|
||||
@Autowired
|
||||
private ExperienceRoleManagementService experienceRoleManagementService;
|
||||
|
||||
@Override
|
||||
public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
|
||||
ARole role = (ARole) commandContext.getParameters().getParameters().get(0);
|
||||
ARole actualRole = roleManagementService.findRole(role.getId());
|
||||
// do not check for the existence of the role, because if the role was deleted, users should be able
|
||||
// to get rid of it in the configuration
|
||||
return experienceRoleService.unsetRole(actualRole, commandContext.getChannel().getIdLong())
|
||||
Optional<AExperienceRole> experienceRole = experienceRoleManagementService.getRoleInServerOptional(actualRole);
|
||||
if(!experienceRole.isPresent()) {
|
||||
throw new ExperienceRoleNotFoundException();
|
||||
}
|
||||
return experienceRoleService.unsetRoles(actualRole, commandContext.getChannel().getIdLong())
|
||||
.thenApply(aVoid -> CommandResult.fromSuccess());
|
||||
}
|
||||
|
||||
|
||||
@@ -31,7 +31,7 @@ public class ExperienceTrackerListener implements AsyncMessageReceivedListener {
|
||||
@Override
|
||||
public DefaultListenerResult execute(MessageReceivedModel model) {
|
||||
Message message = model.getMessage();
|
||||
if(!message.isFromGuild() || message.isWebhookMessage() || message.getType().isSystem()) {
|
||||
if(!message.isFromGuild() || message.isWebhookMessage() || message.getType().isSystem() || message.getAuthor().isBot()) {
|
||||
return DefaultListenerResult.IGNORED;
|
||||
}
|
||||
AUserInAServer cause = userInServerManagementService.loadOrCreateUser(model.getServerId(), model.getMessage().getAuthor().getIdLong());
|
||||
|
||||
@@ -94,24 +94,26 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
try {
|
||||
Long minute = Instant.now().getEpochSecond() / 60;
|
||||
Map<Long, List<ServerExperience>> runtimeExperience = runTimeExperienceService.getRuntimeExperience();
|
||||
Long serverId = userInAServer.getServerReference().getId();
|
||||
Long userInServerId = userInAServer.getUserInServerId();
|
||||
if(runtimeExperience.containsKey(minute)) {
|
||||
log.debug("Minute {} already tracked, adding user {} in server {}.",
|
||||
minute, userInAServer.getUserReference().getId(), userInAServer.getServerReference().getId());
|
||||
minute, userInAServer.getUserReference().getId(), serverId);
|
||||
List<ServerExperience> existing = runtimeExperience.get(minute);
|
||||
for (ServerExperience server : existing) {
|
||||
if (server.getServerId().equals(userInAServer.getServerReference().getId()) && server.getUserInServerIds().stream().noneMatch(userInAServer1 -> userInAServer.getUserInServerId().equals(userInAServer1))) {
|
||||
server.getUserInServerIds().add(userInAServer.getUserInServerId());
|
||||
if (server.getServerId().equals(serverId) && server.getUserInServerIds().stream().noneMatch(userInServerId::equals)) {
|
||||
server.getUserInServerIds().add(userInServerId);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
log.debug("Minute {} did not exist yet. Creating new entry for user {} in server {}.", minute, userInAServer.getUserReference().getId(), userInAServer.getServerReference().getId());
|
||||
log.debug("Minute {} did not exist yet. Creating new entry for user {} in server {}.", minute, userInAServer.getUserReference().getId(), serverId);
|
||||
ServerExperience serverExperience = ServerExperience
|
||||
.builder()
|
||||
.serverId(userInAServer.getServerReference().getId())
|
||||
.serverId(serverId)
|
||||
.build();
|
||||
serverExperience.getUserInServerIds().add(userInAServer.getUserInServerId());
|
||||
serverExperience.getUserInServerIds().add(userInServerId);
|
||||
runtimeExperience.put(minute, new ArrayList<>(Arrays.asList(serverExperience)));
|
||||
}
|
||||
} finally {
|
||||
@@ -180,7 +182,6 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
SystemConfigProperty defaultMinExp = defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MIN_EXP_KEY);
|
||||
SystemConfigProperty defaultMaxExp = defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MAX_EXP_KEY);
|
||||
AServer server = serverManagementService.loadOrCreate(serverId);
|
||||
log.info("Handling {} experience for server {}", memberFutures.size(), serverId);
|
||||
int minExp = configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, serverId, defaultMinExp.getLongValue()).intValue();
|
||||
int maxExp = configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, serverId, defaultMaxExp.getLongValue()).intValue();
|
||||
Double multiplier = configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverId, defaultExpMultiplier.getDoubleValue());
|
||||
@@ -190,18 +191,21 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
List<ADisabledExpRole> disabledExpRoles = disabledExpRoleManagementService.getDisabledRolesForServer(server);
|
||||
List<ARole> disabledRoles = disabledExpRoles.stream().map(ADisabledExpRole::getRole).collect(Collectors.toList());
|
||||
roles.sort(Comparator.comparing(role -> role.getLevel().getLevel()));
|
||||
log.info("Handling {} experiences for server {}. Using {} roles.", memberFutures.size(), serverId, roles.size());
|
||||
memberFutures.forEach(future -> {
|
||||
if(!future.isCompletedExceptionally()) {
|
||||
Integer gainedExperience = iterator.next();
|
||||
gainedExperience = (int) Math.floor(gainedExperience * multiplier);
|
||||
Member member = future.join();
|
||||
AUserInAServer userInAServer = userInServerManagementService.loadOrCreateUser(member);
|
||||
Long userInServerId = userInAServer.getUserInServerId();
|
||||
if(!roleService.hasAnyOfTheRoles(member, disabledRoles)) {
|
||||
log.debug("Handling {}. The user gains {}", userInAServer.getUserReference().getId(), gainedExperience);
|
||||
log.debug("Handling {}. The user might gain {}.", userInServerId, gainedExperience);
|
||||
Optional<AUserExperience> aUserExperienceOptional = userExperienceManagementService.findByUserInServerIdOptional(userInAServer.getUserInServerId());
|
||||
if(aUserExperienceOptional.isPresent()) {
|
||||
AUserExperience aUserExperience = aUserExperienceOptional.get();
|
||||
if(Boolean.FALSE.equals(aUserExperience.getExperienceGainDisabled())) {
|
||||
log.debug("User {} will gain experience.", userInServerId);
|
||||
Long newExperienceCount = aUserExperience.getExperience() + gainedExperience.longValue();
|
||||
AExperienceLevel newLevel = calculateLevel(levels, newExperienceCount);
|
||||
CompletableFuture<RoleCalculationResult> resultFuture = updateUserRole(aUserExperience, roles, newLevel.getLevel());
|
||||
@@ -240,7 +244,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
futures.add(resultFuture);
|
||||
}
|
||||
} else {
|
||||
log.info("User {} has a role which makes the user unable to gain experience.", userInAServer.getUserInServerId());
|
||||
log.debug("User {} has a role which makes the user unable to gain experience.", userInAServer.getUserInServerId());
|
||||
}
|
||||
}
|
||||
});
|
||||
@@ -296,7 +300,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
AUserExperience userExperience;
|
||||
if(experienceGainResult.isCreateUserExperience()) {
|
||||
userExperience = userExperienceManagementService.createUserInServer(user);
|
||||
log.info("Creating new experience user {}", experienceGainResult.getUserInServerId());
|
||||
log.info("Creating new experience user for user in server {}.", experienceGainResult.getUserInServerId());
|
||||
} else {
|
||||
userExperience = userExperienceManagementService.findByUserInServerId(experienceGainResult.getUserInServerId());
|
||||
}
|
||||
@@ -346,7 +350,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
log.debug("User {} in server {} does not have an experience role, according to new calculation.",
|
||||
user.getUserReference().getId(), serverId);
|
||||
// if the user has a experience role currently, remove it
|
||||
if(!currentlyHasNoExperienceRole){
|
||||
if(!currentlyHasNoExperienceRole && !userExperience.getCurrentExperienceRole().getRole().getDeleted()){
|
||||
return roleService.removeRoleFromUserFuture(user, userExperience.getCurrentExperienceRole().getRole())
|
||||
.thenApply(returnNullRole);
|
||||
}
|
||||
@@ -373,16 +377,17 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
// if the roles changed or
|
||||
// the user does not have the new target role already
|
||||
// the user still has the old role
|
||||
if((!userHasRoleAlready || userHasOldRole)) {
|
||||
log.info("User {} in server {} gets a new role {} because of experience.", userId, serverId, roleId);
|
||||
if(!userHasRoleAlready || userHasOldRole) {
|
||||
CompletableFuture<Void> removalFuture;
|
||||
if(userHasOldRole && rolesChanged) {
|
||||
log.info("User {} in server {} loses experience role {}.", userId, serverId, oldUserExperienceRoleId);
|
||||
removalFuture = roleService.removeRoleFromMemberAsync(member, oldUserExperienceRoleId);
|
||||
} else {
|
||||
removalFuture = CompletableFuture.completedFuture(null);
|
||||
}
|
||||
CompletableFuture<Void> addRoleFuture;
|
||||
if(!userHasRoleAlready) {
|
||||
log.info("User {} in server {} gets a new role {} because of experience.", userId, serverId, roleId);
|
||||
addRoleFuture = roleService.addRoleToMemberFuture(member, roleId);
|
||||
} else {
|
||||
addRoleFuture = CompletableFuture.completedFuture(null);
|
||||
@@ -403,7 +408,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
roles.sort(Comparator.comparing(role -> role.getLevel().getLevel()));
|
||||
for (int i = 0; i < aUserExperiences.size(); i++) {
|
||||
AUserExperience userExperience = aUserExperiences.get(i);
|
||||
log.debug("Synchronizing {} out of {}", i, aUserExperiences.size());
|
||||
log.info("Synchronizing {} out of {}. User in Server {}.", i, aUserExperiences.size(), userExperience.getUser().getUserInServerId());
|
||||
results.add(updateUserRole(userExperience, roles, userExperience.getCurrentLevel().getLevel()));
|
||||
}
|
||||
return results;
|
||||
@@ -424,7 +429,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
|
||||
/**
|
||||
* Updates the actually stored experience roles in the database
|
||||
* @param results The list of {@link RoleCalculationResult} which should be applied
|
||||
* @param results The list of {@link RoleCalculationResult results} which should be applied
|
||||
*/
|
||||
@Transactional
|
||||
public void syncRolesInStorage(List<RoleCalculationResult> results) {
|
||||
@@ -461,12 +466,13 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
int interval = Math.min(Math.max(experiences.size() / 10, 1), 100);
|
||||
for (int i = 0; i < experiences.size(); i++) {
|
||||
if((i % interval) == 1) {
|
||||
log.debug("Updating feedback message with new index {} out of {}", i, experiences.size());
|
||||
log.info("Updating feedback message with new index {} out of {}.", i, experiences.size());
|
||||
status = getUserSyncStatusUpdateModel(i, experiences.size(), serverId);
|
||||
messageService.updateStatusMessage(channel, statusMessage.getIdLong(), status);
|
||||
}
|
||||
futures.add(toExecute.apply(experiences.get(i)));
|
||||
log.debug("Synchronizing {} out of {}", i, experiences.size());
|
||||
AUserExperience userExperience = experiences.get(i);
|
||||
futures.add(toExecute.apply(userExperience));
|
||||
log.debug("Synchronizing {} out of {}. User in server ID {}.", i, experiences.size(), userExperience.getUser().getUserInServerId());
|
||||
}
|
||||
status = getUserSyncStatusUpdateModel(experiences.size(), experiences.size(), serverId);
|
||||
messageService.updateStatusMessage(channel, statusMessage.getIdLong(), status);
|
||||
@@ -483,8 +489,8 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
|
||||
@Override
|
||||
public void enableExperienceForUser(AUserInAServer userInAServer) {
|
||||
AUserExperience userExperience = userExperienceManagementService.findUserInServer(userInAServer);
|
||||
log.info("Enabling experience gain for user {} in server {}.", userInAServer.getUserReference().getId(), userInAServer.getServerReference().getId());
|
||||
AUserExperience userExperience = userExperienceManagementService.findUserInServer(userInAServer);
|
||||
userExperience.setExperienceGainDisabled(false);
|
||||
}
|
||||
|
||||
@@ -503,7 +509,7 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
@Override
|
||||
public CompletableFuture<RoleCalculationResult> syncForSingleUser(AUserExperience userExperience) {
|
||||
AUserInAServer user = userExperience.getUser();
|
||||
log.info("Synchronizing for user {} in server {}", user.getUserReference().getId(), user.getServerReference().getId());
|
||||
log.info("Synchronizing for user {} in server {}.", user.getUserReference().getId(), user.getServerReference().getId());
|
||||
List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(user.getServerReference());
|
||||
roles.sort(Comparator.comparing(role -> role.getLevel().getLevel()));
|
||||
return updateUserRole(userExperience, roles, userExperience.getLevelOrDefault());
|
||||
|
||||
@@ -57,7 +57,7 @@ public class ExperienceLevelServiceBean implements ExperienceLevelService {
|
||||
|
||||
@Override
|
||||
public Long calculateExperienceToNextLevel(Integer level, Long currentExperience) {
|
||||
AExperienceLevel nextLevel = experienceLevelManagementService.getLevel(level + 1)
|
||||
AExperienceLevel nextLevel = experienceLevelManagementService.getLevelOptional(level + 1)
|
||||
.orElseThrow(() -> new AbstractoRunTimeException(String.format("Could not find level %s", level)));
|
||||
return nextLevel.getExperienceNeeded() - currentExperience;
|
||||
}
|
||||
|
||||
@@ -3,6 +3,7 @@ package dev.sheldan.abstracto.experience.service;
|
||||
import dev.sheldan.abstracto.core.models.database.AChannel;
|
||||
import dev.sheldan.abstracto.core.models.database.ARole;
|
||||
import dev.sheldan.abstracto.core.models.database.AServer;
|
||||
import dev.sheldan.abstracto.core.service.RoleService;
|
||||
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
|
||||
import dev.sheldan.abstracto.core.service.management.RoleManagementService;
|
||||
import dev.sheldan.abstracto.core.utils.CompletableFutureList;
|
||||
@@ -10,6 +11,7 @@ import dev.sheldan.abstracto.experience.model.RoleCalculationResult;
|
||||
import dev.sheldan.abstracto.experience.model.database.AExperienceLevel;
|
||||
import dev.sheldan.abstracto.experience.model.database.AExperienceRole;
|
||||
import dev.sheldan.abstracto.experience.model.database.AUserExperience;
|
||||
import dev.sheldan.abstracto.experience.model.template.LevelRole;
|
||||
import dev.sheldan.abstracto.experience.service.management.ExperienceLevelManagementService;
|
||||
import dev.sheldan.abstracto.experience.service.management.ExperienceRoleManagementService;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
@@ -18,9 +20,7 @@ import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.stereotype.Component;
|
||||
import org.springframework.transaction.annotation.Transactional;
|
||||
|
||||
import java.util.Comparator;
|
||||
import java.util.List;
|
||||
import java.util.Optional;
|
||||
import java.util.*;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
@@ -46,6 +46,9 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
|
||||
@Autowired
|
||||
private ChannelManagementService channelManagementService;
|
||||
|
||||
@Autowired
|
||||
private RoleService roleService;
|
||||
|
||||
/**
|
||||
* UnSets the current configuration for the passed level, and sets the {@link ARole} to be used for this level
|
||||
* in the given {@link AServer}
|
||||
@@ -55,14 +58,43 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
|
||||
@Override
|
||||
public CompletableFuture<Void> setRoleToLevel(Role role, Integer level, Long channelId) {
|
||||
Long roleId = role.getIdLong();
|
||||
ARole aRole = roleManagementService.findRole(roleId);
|
||||
return unsetRole(aRole, channelId).thenAccept(aVoid ->
|
||||
ARole aRoleToSet = roleManagementService.findRole(roleId);
|
||||
List<AExperienceRole> experienceRoles = getExperienceRolesAtLevel(level, aRoleToSet.getServer());
|
||||
List<ARole> rolesToUnset = experienceRoles.stream().map(AExperienceRole::getRole).collect(Collectors.toList());
|
||||
if(rolesToUnset.size() == 1 && rolesToUnset.contains(aRoleToSet)) {
|
||||
return CompletableFuture.completedFuture(null);
|
||||
}
|
||||
if(!rolesToUnset.contains(aRoleToSet)) {
|
||||
rolesToUnset.add(aRoleToSet);
|
||||
}
|
||||
AExperienceLevel experienceLevel;
|
||||
if(!experienceRoles.isEmpty()) {
|
||||
experienceLevel = experienceRoles.get(0).getLevel();
|
||||
} else {
|
||||
experienceLevel = experienceLevelService.getLevel(level);
|
||||
}
|
||||
AExperienceRole newExperienceRole = experienceRoleManagementService.setLevelToRole(experienceLevel, aRoleToSet);
|
||||
Long newlyCreatedExperienceRoleId = newExperienceRole.getId();
|
||||
CompletableFuture<Void> future = new CompletableFuture<>();
|
||||
unsetRoles(rolesToUnset, channelId, newExperienceRole).thenAccept(aVoid ->
|
||||
self.unsetRoleInDb(level, roleId)
|
||||
);
|
||||
).thenAccept(unused -> future.complete(null)).exceptionally(throwable -> {
|
||||
self.deleteExperienceRoleViaId(newlyCreatedExperienceRoleId);
|
||||
future.completeExceptionally(throwable);
|
||||
return null;
|
||||
});
|
||||
|
||||
return future;
|
||||
}
|
||||
|
||||
@Transactional
|
||||
public void deleteExperienceRoleViaId(Long newlyCreatedExperienceRoleId) {
|
||||
AExperienceRole reLoadedRole = experienceRoleManagementService.getExperienceRoleById(newlyCreatedExperienceRoleId);
|
||||
experienceRoleManagementService.unsetRole(reLoadedRole);
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes all previous defined {@link AExperienceRole experienceRoles} from the given leve and sets the {@link ARole}
|
||||
* Removes all previous defined {@link AExperienceRole experienceRoles} from the given level and sets the {@link ARole}
|
||||
* (defined by its ID) to the level.
|
||||
* @param level The level which the {@link ARole role} should be set to
|
||||
* @param roleId The ID of the {@link Role} which should have its level set
|
||||
@@ -70,9 +102,9 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
|
||||
@Transactional
|
||||
public void unsetRoleInDb(Integer level, Long roleId) {
|
||||
log.info("Unsetting role {} from level {}.", roleId, level);
|
||||
AExperienceLevel experienceLevel = experienceLevelService.getLevel(level).orElseThrow(() -> new IllegalArgumentException(String.format("Could not find level %s", level)));
|
||||
AExperienceLevel experienceLevel = experienceLevelService.getLevelOptional(level).orElseThrow(() -> new IllegalArgumentException(String.format("Could not find level %s", level)));
|
||||
ARole loadedRole = roleManagementService.findRole(roleId);
|
||||
experienceRoleManagementService.removeAllRoleAssignmentsForLevelInServer(experienceLevel, loadedRole.getServer());
|
||||
experienceRoleManagementService.removeAllRoleAssignmentsForLevelInServerExceptRole(experienceLevel, loadedRole.getServer(), loadedRole);
|
||||
experienceRoleManagementService.setLevelToRole(experienceLevel, loadedRole);
|
||||
}
|
||||
|
||||
@@ -83,31 +115,54 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
|
||||
* configuration
|
||||
*/
|
||||
@Override
|
||||
public CompletableFuture<Void> unsetRole(ARole role, Long feedbackChannelId) {
|
||||
AChannel channel = channelManagementService.loadChannel(feedbackChannelId);
|
||||
Optional<AExperienceRole> roleInServerOptional = experienceRoleManagementService.getRoleInServerOptional(role);
|
||||
if(roleInServerOptional.isPresent()) {
|
||||
AExperienceRole roleInServer = roleInServerOptional.get();
|
||||
if(!roleInServer.getUsers().isEmpty()) {
|
||||
log.info("Recalculating the roles for {} users, because their current role was removed from experience tracking.", roleInServer.getUsers().size());
|
||||
List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(role.getServer());
|
||||
roles.removeIf(role1 -> role1.getId().equals(roleInServer.getId()));
|
||||
roles.sort(Comparator.comparing(innerRole -> innerRole.getLevel().getLevel()));
|
||||
Long roleId = role.getId();
|
||||
CompletableFutureList<RoleCalculationResult> calculationResults = userExperienceService.executeActionOnUserExperiencesWithFeedBack(roleInServer.getUsers(), channel,
|
||||
(AUserExperience ex) -> userExperienceService.updateUserRole(ex, roles, ex.getLevelOrDefault()));
|
||||
return calculationResults.getMainFuture().thenAccept(aVoid ->
|
||||
self.persistData(calculationResults, roleId)
|
||||
);
|
||||
} else {
|
||||
log.info("Roles does not have any active users, no need to remove them.");
|
||||
experienceRoleManagementService.unsetRole(roleInServer);
|
||||
return CompletableFuture.completedFuture(null);
|
||||
}
|
||||
} else {
|
||||
log.info("Experience role is not define in server - skipping unset.");
|
||||
public CompletableFuture<Void> unsetRoles(ARole role, Long feedbackChannelId) {
|
||||
return unsetRoles(Arrays.asList(role), feedbackChannelId);
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<AExperienceRole> getExperienceRolesAtLevel(Integer level, AServer server) {
|
||||
AExperienceLevel levelObj = experienceLevelService.getLevel(level);
|
||||
return experienceRoleManagementService.getExperienceRolesAtLevelInServer(levelObj, server);
|
||||
}
|
||||
|
||||
@Override
|
||||
public CompletableFuture<Void> unsetRoles(List<ARole> rolesToUnset, Long feedbackChannelId) {
|
||||
return unsetRoles(rolesToUnset, feedbackChannelId, null);
|
||||
}
|
||||
|
||||
@Override
|
||||
public CompletableFuture<Void> unsetRoles(List<ARole> rolesToUnset, Long feedbackChannelId, AExperienceRole toAdd) {
|
||||
if(rolesToUnset.isEmpty()) {
|
||||
return CompletableFuture.completedFuture(null);
|
||||
}
|
||||
AServer server = rolesToUnset.get(0).getServer();
|
||||
AChannel channel = channelManagementService.loadChannel(feedbackChannelId);
|
||||
List<AExperienceRole> experienceRolesNecessaryToRemove = new ArrayList<>();
|
||||
List<AUserExperience> usersToUpdate = new ArrayList<>();
|
||||
rolesToUnset.forEach(role -> {
|
||||
Optional<AExperienceRole> roleInServerOptional = experienceRoleManagementService.getRoleInServerOptional(role);
|
||||
if(roleInServerOptional.isPresent()) {
|
||||
AExperienceRole experienceRole = roleInServerOptional.get();
|
||||
experienceRolesNecessaryToRemove.add(experienceRole);
|
||||
usersToUpdate.addAll(experienceRole.getUsers());
|
||||
} else {
|
||||
log.info("Experience role {} is not defined in server {} - skipping unset.", role.getId(), server.getId());
|
||||
}
|
||||
});
|
||||
log.info("Recalculating the roles for {} users, because their current role was removed from experience tracking.", usersToUpdate.size());
|
||||
List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);
|
||||
roles.removeIf(role1 -> experienceRolesNecessaryToRemove.stream().anyMatch(aExperienceRole -> aExperienceRole.getId().equals(role1.getId())));
|
||||
if(toAdd != null) {
|
||||
roles.add(toAdd);
|
||||
}
|
||||
roles.sort(Comparator.comparing(innerRole -> innerRole.getLevel().getLevel()));
|
||||
List<Long> roleIds = experienceRolesNecessaryToRemove.stream().map(AExperienceRole::getId).collect(Collectors.toList());
|
||||
if(toAdd != null) {
|
||||
roleIds.removeIf(aLong -> aLong.equals(toAdd.getRole().getId()));
|
||||
}
|
||||
CompletableFutureList<RoleCalculationResult> calculationResults = userExperienceService.executeActionOnUserExperiencesWithFeedBack(usersToUpdate, channel,
|
||||
(AUserExperience ex) -> userExperienceService.updateUserRole(ex, roles, ex.getLevelOrDefault()));
|
||||
return calculationResults.getMainFuture().thenAccept(aVoid -> self.persistData(calculationResults, roleIds));
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -116,13 +171,15 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
|
||||
* have to remove the existing {@link AExperienceRole experienceRole}
|
||||
* @param results A list of {@link CompletableFuture futures} which each contain a {@link RoleCalculationResult result}, for the members who got
|
||||
* their {@link AExperienceRole experienceRole} removed
|
||||
* @param roleId The ID of the {@link AExperienceRole experienceRole} which was removed from the experience roles
|
||||
* @param roleIds The IDs of the {@link AExperienceRole experienceRoles} which were removed from the experience roles
|
||||
*/
|
||||
@Transactional
|
||||
public void persistData(CompletableFutureList<RoleCalculationResult> results, Long roleId) {
|
||||
log.info("Persisting {} role calculation results after changing the role {}.", results.getFutures().size(), roleId);
|
||||
AExperienceRole roleInServer = experienceRoleManagementService.getExperienceRoleById(roleId);
|
||||
experienceRoleManagementService.unsetRole(roleInServer);
|
||||
public void persistData(CompletableFutureList<RoleCalculationResult> results, List<Long> roleIds) {
|
||||
log.info("Persisting {} role calculation results.", results.getFutures().size());
|
||||
roleIds.forEach(roleId -> {
|
||||
log.info("Deleting experience role {}.", roleId);
|
||||
deleteExperienceRoleViaId(roleId);
|
||||
});
|
||||
userExperienceService.syncRolesInStorage(results.getObjects());
|
||||
}
|
||||
|
||||
@@ -153,4 +210,21 @@ public class ExperienceRoleServiceBean implements ExperienceRoleService {
|
||||
return aExperienceRole != null ? aExperienceRole.getLevel() : AExperienceLevel.builder().level(200).build();
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<LevelRole> loadLevelRoleConfigForServer(AServer server) {
|
||||
List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);
|
||||
List<LevelRole> levelRoles = new ArrayList<>();
|
||||
roles.forEach(aExperienceRole -> {
|
||||
Role role = roleService.getRoleFromGuild(aExperienceRole.getRole());
|
||||
LevelRole levelRole = LevelRole
|
||||
.builder()
|
||||
.role(role)
|
||||
.roleId(aExperienceRole.getId())
|
||||
.level(aExperienceRole.getLevel().getLevel())
|
||||
.build();
|
||||
levelRoles.add(levelRole);
|
||||
});
|
||||
return levelRoles;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
package dev.sheldan.abstracto.experience.service.management;
|
||||
|
||||
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
|
||||
import dev.sheldan.abstracto.experience.model.database.AExperienceLevel;
|
||||
import dev.sheldan.abstracto.experience.repository.ExperienceLevelRepository;
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
@@ -9,7 +10,7 @@ import java.util.List;
|
||||
import java.util.Optional;
|
||||
|
||||
@Component
|
||||
public class ExperienceLevelManagementServiceBean implements ExperienceLevelManagementService {
|
||||
public class ExperienceLevelManagementServiceBean implements ExperienceLevelManagementService {
|
||||
|
||||
@Autowired
|
||||
private ExperienceLevelRepository experienceLevelRepository;
|
||||
@@ -30,10 +31,15 @@ public class ExperienceLevelManagementServiceBean implements ExperienceLevelM
|
||||
}
|
||||
|
||||
@Override
|
||||
public Optional<AExperienceLevel> getLevel(Integer level) {
|
||||
public Optional<AExperienceLevel> getLevelOptional(Integer level) {
|
||||
return experienceLevelRepository.findById(level);
|
||||
}
|
||||
|
||||
@Override
|
||||
public AExperienceLevel getLevel(Integer level) {
|
||||
return getLevelOptional(level).orElseThrow(() -> new AbstractoRunTimeException("Level not found."));
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<AExperienceLevel> getLevelConfig() {
|
||||
return experienceLevelRepository.findAll();
|
||||
|
||||
@@ -30,10 +30,14 @@ public class ExperienceRoleManagementServiceBean implements ExperienceRoleManage
|
||||
* @param server The server in which this should happen
|
||||
*/
|
||||
@Override
|
||||
public void removeAllRoleAssignmentsForLevelInServer(AExperienceLevel level, AServer server) {
|
||||
public void removeAllRoleAssignmentsForLevelInServerExceptRole(AExperienceLevel level, AServer server, ARole role) {
|
||||
List<AExperienceRole> existingExperienceRoles = experienceRoleRepository.findByLevelAndRoleServer(level, server);
|
||||
log.info("Removing all role assignments ({}) for level {} in server {}.", existingExperienceRoles.size(), level.getLevel(), server.getId());
|
||||
existingExperienceRoles.forEach(existingRole -> experienceRoleRepository.delete(existingRole));
|
||||
existingExperienceRoles.forEach(existingRole -> {
|
||||
if(!existingRole.getRole().getId().equals(role.getId())) {
|
||||
experienceRoleRepository.delete(existingRole);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -97,4 +101,9 @@ public class ExperienceRoleManagementServiceBean implements ExperienceRoleManage
|
||||
}
|
||||
return experienceRole;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<AExperienceRole> getExperienceRolesAtLevelInServer(AExperienceLevel level, AServer server) {
|
||||
return experienceRoleRepository.findByLevelAndRoleServer(level, server);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -45,7 +45,7 @@ public class UserExperienceManagementServiceBean implements UserExperienceManage
|
||||
@Override
|
||||
public AUserExperience createUserInServer(AUserInAServer aUserInAServer) {
|
||||
log.info("Creating user experience for user {} in server {}.", aUserInAServer.getUserReference().getId(),aUserInAServer.getServerReference().getId());
|
||||
AExperienceLevel startingLevel = experienceLevelManagementService.getLevel(0).orElseThrow(() -> new AbstractoRunTimeException(String.format("Could not find level %s", 0)));
|
||||
AExperienceLevel startingLevel = experienceLevelManagementService.getLevelOptional(0).orElseThrow(() -> new AbstractoRunTimeException(String.format("Could not find level %s", 0)));
|
||||
return AUserExperience
|
||||
.builder()
|
||||
.experience(0L)
|
||||
|
||||
@@ -64,6 +64,11 @@
|
||||
<column name="module_id" valueComputed="${experienceModule}"/>
|
||||
<column name="feature_id" valueComputed="${experienceFeature}"/>
|
||||
</insert>
|
||||
<insert tableName="command">
|
||||
<column name="name" value="levelRoles"/>
|
||||
<column name="module_id" valueComputed="${experienceModule}"/>
|
||||
<column name="feature_id" valueComputed="${experienceFeature}"/>
|
||||
</insert>
|
||||
</changeSet>
|
||||
|
||||
</databaseChangeLog>
|
||||
@@ -6,7 +6,9 @@ import dev.sheldan.abstracto.core.models.database.ARole;
|
||||
import dev.sheldan.abstracto.core.service.management.RoleManagementService;
|
||||
import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
|
||||
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
|
||||
import dev.sheldan.abstracto.experience.model.database.AExperienceRole;
|
||||
import dev.sheldan.abstracto.experience.service.ExperienceRoleService;
|
||||
import dev.sheldan.abstracto.experience.service.management.ExperienceRoleManagementService;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.InjectMocks;
|
||||
@@ -15,6 +17,7 @@ import org.mockito.Mockito;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Optional;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
|
||||
import static org.mockito.Mockito.when;
|
||||
@@ -31,6 +34,9 @@ public class UnSetExpRoleTest {
|
||||
@Mock
|
||||
private RoleManagementService roleManagementService;
|
||||
|
||||
@Mock
|
||||
private ExperienceRoleManagementService experienceRoleManagementService;
|
||||
|
||||
private static final Long CHANNEL_ID = 4L;
|
||||
|
||||
@Test
|
||||
@@ -41,7 +47,8 @@ public class UnSetExpRoleTest {
|
||||
when(context.getChannel().getIdLong()).thenReturn(CHANNEL_ID);
|
||||
ARole actualRole = Mockito.mock(ARole.class);
|
||||
when(roleManagementService.findRole(changedRole.getId())).thenReturn(actualRole);
|
||||
when(experienceRoleService.unsetRole(actualRole, CHANNEL_ID)).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(experienceRoleManagementService.getRoleInServerOptional(actualRole)).thenReturn(Optional.of(Mockito.mock(AExperienceRole.class)));
|
||||
when(experienceRoleService.unsetRoles(actualRole, CHANNEL_ID)).thenReturn(CompletableFuture.completedFuture(null));
|
||||
CompletableFuture<CommandResult> result = testUnit.executeAsync(context);
|
||||
CommandTestUtilities.checkSuccessfulCompletionAsync(result);
|
||||
}
|
||||
|
||||
@@ -409,7 +409,6 @@ public class AUserExperienceServiceBeanTest {
|
||||
setupDefaultConfig();
|
||||
setupLevelsAndRolesAndNoDisallowed();
|
||||
setExperienceRoleLevels();
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(userExperience.getExperienceGainDisabled()).thenReturn(true);
|
||||
|
||||
ArrayList<ExperienceGainResult> experienceResults = new ArrayList<>();
|
||||
|
||||
@@ -38,7 +38,7 @@ public class ExperienceLevelServiceBeanTest {
|
||||
public void testExperienceToNextLevelCalculation() {
|
||||
AExperienceLevel level = mock(AExperienceLevel.class);
|
||||
when(level.getExperienceNeeded()).thenReturn(15L);
|
||||
when(experienceLevelManagementService.getLevel(51)).thenReturn(Optional.of(level));
|
||||
when(experienceLevelManagementService.getLevelOptional(51)).thenReturn(Optional.of(level));
|
||||
Long experience = testingUnit.calculateExperienceToNextLevel(50, 10L);
|
||||
Assert.assertEquals(5L, experience.longValue());
|
||||
}
|
||||
@@ -55,7 +55,7 @@ public class ExperienceLevelServiceBeanTest {
|
||||
|
||||
@Test(expected = AbstractoRunTimeException.class)
|
||||
public void testExperienceToNextLevelCalculationOverExistingLevel() {
|
||||
when(experienceLevelManagementService.getLevel(51)).thenReturn(Optional.empty());
|
||||
when(experienceLevelManagementService.getLevelOptional(51)).thenReturn(Optional.empty());
|
||||
testingUnit.calculateExperienceToNextLevel(50, 10L);
|
||||
}
|
||||
|
||||
|
||||
@@ -59,65 +59,21 @@ public class ExperienceRoleServiceBeanTest {
|
||||
private static final Long CHANNEL_ID = 4L;
|
||||
private static final Long ROLE_ID = 5L;
|
||||
|
||||
@Test
|
||||
public void testSettingRoleToLevelWithoutOldUsers() {
|
||||
Integer levelCount = 10;
|
||||
Role roleToChange = Mockito.mock(Role.class);
|
||||
ARole role = Mockito.mock(ARole.class);
|
||||
when(roleToChange.getIdLong()).thenReturn(ROLE_ID);
|
||||
when(roleManagementService.findRole(ROLE_ID)).thenReturn(role);
|
||||
AExperienceRole previousExperienceRole = Mockito.mock(AExperienceRole.class);
|
||||
when(experienceRoleManagementService.getRoleInServerOptional(role)).thenReturn(Optional.of(previousExperienceRole));
|
||||
CompletableFuture<Void> future = testingUnit.setRoleToLevel(roleToChange, levelCount, CHANNEL_ID);
|
||||
|
||||
future.join();
|
||||
verify(experienceRoleManagementService, times(1)).unsetRole(previousExperienceRole);
|
||||
verify(self, times(1)).unsetRoleInDb(levelCount, ROLE_ID);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUnsetRoleInDb() {
|
||||
Integer levelCount = 10;
|
||||
AExperienceLevel level = Mockito.mock(AExperienceLevel.class);
|
||||
ARole roleToChange = Mockito.mock(ARole.class);
|
||||
when(roleToChange.getServer()).thenReturn(server);
|
||||
when(experienceLevelService.getLevel(levelCount)).thenReturn(Optional.of(level));
|
||||
when(experienceLevelService.getLevelOptional(levelCount)).thenReturn(Optional.of(level));
|
||||
when(roleManagementService.findRole(roleToChange.getId())).thenReturn(roleToChange);
|
||||
testingUnit.unsetRoleInDb(levelCount, roleToChange.getId());
|
||||
|
||||
verify(experienceRoleManagementService, times(1)).removeAllRoleAssignmentsForLevelInServer(level, server);
|
||||
verify(experienceRoleManagementService, times(1)).removeAllRoleAssignmentsForLevelInServerExceptRole(level, server, roleToChange);
|
||||
verify(experienceRoleManagementService, times(1)).setLevelToRole(level, roleToChange);
|
||||
verify(experienceRoleManagementService, times(0)).getExperienceRolesForServer(server);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testSettingRoleToLevelExistingUsers() {
|
||||
Integer levelCount = 10;
|
||||
Role roleToChange = Mockito.mock(Role.class);
|
||||
ARole role = Mockito.mock(ARole.class);
|
||||
when(roleToChange.getIdLong()).thenReturn(ROLE_ID);
|
||||
when(roleManagementService.findRole(ROLE_ID)).thenReturn(role);
|
||||
when(role.getServer()).thenReturn(server);
|
||||
AUserExperience firstUser = Mockito.mock(AUserExperience.class);
|
||||
AUserExperience secondUser = Mockito.mock(AUserExperience.class);
|
||||
List<AUserExperience> users = Arrays.asList(firstUser, secondUser);
|
||||
AExperienceRole previousExperienceRole = Mockito.mock(AExperienceRole.class);
|
||||
when(previousExperienceRole.getUsers()).thenReturn(users);
|
||||
AExperienceRole newExperienceRole = Mockito.mock(AExperienceRole.class);
|
||||
when(experienceRoleManagementService.getRoleInServerOptional(role)).thenReturn(Optional.of(previousExperienceRole));
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(new ArrayList<>(Arrays.asList(newExperienceRole, previousExperienceRole)));
|
||||
List<CompletableFuture<RoleCalculationResult>> futures = new ArrayList<>();
|
||||
futures.add(CompletableFuture.completedFuture(null));
|
||||
AChannel feedbackChannel = Mockito.mock(AChannel.class);
|
||||
when(channelManagementService.loadChannel(CHANNEL_ID)).thenReturn(feedbackChannel);
|
||||
CompletableFutureList<RoleCalculationResult> futuresList = new CompletableFutureList<>(futures);
|
||||
when(userExperienceService.executeActionOnUserExperiencesWithFeedBack(eq(users), eq(feedbackChannel), any())).thenReturn(futuresList);
|
||||
CompletableFuture<Void> future = testingUnit.setRoleToLevel(roleToChange, levelCount, CHANNEL_ID);
|
||||
future.join();
|
||||
verify(experienceRoleManagementService, times(0)).unsetRole(previousExperienceRole);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCalculateRoleForLevelInBetween() {
|
||||
List<AExperienceRole> roles = getExperienceRoles();
|
||||
|
||||
@@ -54,7 +54,7 @@ public class ExperienceLevelManagementServiceBeanTest {
|
||||
when(level.getLevel()).thenReturn(levelValue);
|
||||
when(level.getExperienceNeeded()).thenReturn(experienceAmount);
|
||||
when(experienceLevelRepository.findById(levelValue)).thenReturn(Optional.of(level));
|
||||
Optional<AExperienceLevel> foundLevelOptional = testUnit.getLevel(levelValue);
|
||||
Optional<AExperienceLevel> foundLevelOptional = testUnit.getLevelOptional(levelValue);
|
||||
Assert.assertTrue(foundLevelOptional.isPresent());
|
||||
if(foundLevelOptional.isPresent()) {
|
||||
AExperienceLevel foundLevel = foundLevelOptional.get();
|
||||
@@ -70,7 +70,7 @@ public class ExperienceLevelManagementServiceBeanTest {
|
||||
int levelValue = 1;
|
||||
Optional<AExperienceLevel> level = Optional.empty();
|
||||
when(experienceLevelRepository.findById(levelValue)).thenReturn(level);
|
||||
Optional<AExperienceLevel> foundLevelOptional = testUnit.getLevel(levelValue);
|
||||
Optional<AExperienceLevel> foundLevelOptional = testUnit.getLevelOptional(levelValue);
|
||||
Assert.assertFalse(foundLevelOptional.isPresent());
|
||||
}
|
||||
|
||||
|
||||
@@ -50,9 +50,14 @@ public class ExperienceRoleManagementServiceBeanTest {
|
||||
public void testRemovingAllRoleAssignmentsForLevel() {
|
||||
when(level.getLevel()).thenReturn(10);
|
||||
AExperienceRole secondRole = Mockito.mock(AExperienceRole.class);
|
||||
ARole anotherARole = Mockito.mock(ARole.class);
|
||||
when(anotherARole.getId()).thenReturn(ROLE_ID + 1);
|
||||
when(role.getId()).thenReturn(ROLE_ID);
|
||||
when(experienceRole.getRole()).thenReturn(anotherARole);
|
||||
when(secondRole.getRole()).thenReturn(anotherARole);
|
||||
List<AExperienceRole> experienceRoles = Arrays.asList(experienceRole, secondRole);
|
||||
when(experienceRoleRepository.findByLevelAndRoleServer(level, server)).thenReturn(experienceRoles);
|
||||
testUnit.removeAllRoleAssignmentsForLevelInServer(level, server);
|
||||
testUnit.removeAllRoleAssignmentsForLevelInServerExceptRole(level, server, role);
|
||||
verify(experienceRoleRepository, times(1)).findByLevelAndRoleServer(level, server);
|
||||
verify(experienceRoleRepository, times(experienceRoles.size())).delete(roleArgumentCaptor.capture());
|
||||
List<AExperienceRole> allValues = roleArgumentCaptor.getAllValues();
|
||||
@@ -66,7 +71,7 @@ public class ExperienceRoleManagementServiceBeanTest {
|
||||
when(level.getLevel()).thenReturn(10);
|
||||
List<AExperienceRole> experienceRoles = new ArrayList<>();
|
||||
when(experienceRoleRepository.findByLevelAndRoleServer(level, server)).thenReturn(experienceRoles);
|
||||
testUnit.removeAllRoleAssignmentsForLevelInServer(level, server);
|
||||
testUnit.removeAllRoleAssignmentsForLevelInServerExceptRole(level, server, role);
|
||||
verify(experienceRoleRepository, times(1)).findByLevelAndRoleServer(level, server);
|
||||
verify(experienceRoleRepository, times(experienceRoles.size())).delete(roleArgumentCaptor.capture());
|
||||
List<AExperienceRole> allValues = roleArgumentCaptor.getAllValues();
|
||||
|
||||
@@ -62,7 +62,7 @@ public class UserExperienceManagementServiceBeanTest {
|
||||
when(repository.findById(USER_IN_SERVER_ID)).thenReturn(Optional.empty());
|
||||
AExperienceLevel startLevel = Mockito.mock(AExperienceLevel.class);
|
||||
when(startLevel.getLevel()).thenReturn(START_LEVEL);
|
||||
when(experienceLevelManagementService.getLevel(START_LEVEL)).thenReturn(Optional.of(startLevel));
|
||||
when(experienceLevelManagementService.getLevelOptional(START_LEVEL)).thenReturn(Optional.of(startLevel));
|
||||
AUserExperience userInServer = testUnit.findUserInServer(user);
|
||||
Assert.assertEquals(0L, userInServer.getExperience().longValue());
|
||||
Assert.assertEquals(0L, userInServer.getMessageCount().longValue());
|
||||
@@ -81,7 +81,7 @@ public class UserExperienceManagementServiceBeanTest {
|
||||
when(user.getUserReference()).thenReturn(aUser);
|
||||
AExperienceLevel startLevel = Mockito.mock(AExperienceLevel.class);
|
||||
when(startLevel.getLevel()).thenReturn(START_LEVEL);
|
||||
when(experienceLevelManagementService.getLevel(START_LEVEL)).thenReturn(Optional.of(startLevel));
|
||||
when(experienceLevelManagementService.getLevelOptional(START_LEVEL)).thenReturn(Optional.of(startLevel));
|
||||
AUserExperience userInServer = testUnit.createUserInServer(user);
|
||||
Assert.assertEquals(0L, userInServer.getExperience().longValue());
|
||||
Assert.assertEquals(0L, userInServer.getMessageCount().longValue());
|
||||
|
||||
@@ -0,0 +1,23 @@
|
||||
package dev.sheldan.abstracto.experience.exception;
|
||||
|
||||
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
|
||||
import dev.sheldan.abstracto.core.templating.Templatable;
|
||||
import org.springframework.stereotype.Component;
|
||||
|
||||
@Component
|
||||
public class ExperienceRoleNotFoundException extends AbstractoRunTimeException implements Templatable {
|
||||
|
||||
public ExperienceRoleNotFoundException() {
|
||||
super("Experience role was not found for role.");
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getTemplateName() {
|
||||
return "experience_role_not_found_exception";
|
||||
}
|
||||
|
||||
@Override
|
||||
public Object getTemplateModel() {
|
||||
return new Object();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
package dev.sheldan.abstracto.experience.model.template;
|
||||
|
||||
import lombok.Builder;
|
||||
import lombok.Getter;
|
||||
import net.dv8tion.jda.api.entities.Role;
|
||||
|
||||
@Getter
|
||||
@Builder
|
||||
public class LevelRole {
|
||||
private Role role;
|
||||
private Long roleId;
|
||||
private Integer level;
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
package dev.sheldan.abstracto.experience.model.template;
|
||||
|
||||
import lombok.Builder;
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
@Getter
|
||||
@Setter
|
||||
@Builder
|
||||
public class LevelRolesModel {
|
||||
private List<LevelRole> levelRoles;
|
||||
}
|
||||
@@ -5,6 +5,7 @@ import dev.sheldan.abstracto.core.models.database.AServer;
|
||||
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 net.dv8tion.jda.api.entities.Role;
|
||||
|
||||
import java.util.List;
|
||||
@@ -38,7 +39,10 @@ public interface ExperienceRoleService {
|
||||
* @return A {@link CompletableFuture future} which completes, after all the updates on the {@link net.dv8tion.jda.api.entities.Member}
|
||||
* have been completed
|
||||
*/
|
||||
CompletableFuture<Void> unsetRole(ARole role, Long channelId);
|
||||
CompletableFuture<Void> unsetRoles(ARole role, Long channelId);
|
||||
List<AExperienceRole> getExperienceRolesAtLevel(Integer level, AServer server);
|
||||
CompletableFuture<Void> unsetRoles(List<ARole> roles, Long channelId);
|
||||
CompletableFuture<Void> unsetRoles(List<ARole> roles, Long channelId, AExperienceRole toAdd);
|
||||
|
||||
/**
|
||||
* Calculates the appropriate {@link AExperienceRole experienceRole} based on the provided list of {@link AExperienceRole experienceRole}
|
||||
@@ -57,4 +61,5 @@ public interface ExperienceRoleService {
|
||||
* @return The next {@link AExperienceLevel} a {@link AExperienceRole} is awarded at, this will be null if there are no roles or there is no further role to reach
|
||||
*/
|
||||
AExperienceLevel getLevelOfNextRole(AExperienceLevel startLevel, AServer server);
|
||||
List<LevelRole> loadLevelRoleConfigForServer(AServer server);
|
||||
}
|
||||
|
||||
@@ -29,7 +29,8 @@ public interface ExperienceLevelManagementService {
|
||||
* @param level The {@link AExperienceLevel level} of the wanted level number
|
||||
* @return Returns an optional containing the {@link AExperienceLevel level} if it exists, and empty otherwise
|
||||
*/
|
||||
Optional<AExperienceLevel> getLevel(Integer level);
|
||||
Optional<AExperienceLevel> getLevelOptional(Integer level);
|
||||
AExperienceLevel getLevel(Integer level);
|
||||
|
||||
/**
|
||||
* Loads the complete level configuration and returns all found {@link AExperienceLevel levels} from the database.
|
||||
|
||||
@@ -23,13 +23,14 @@ public interface ExperienceRoleManagementService {
|
||||
* @return the created or updated {@link AExperienceRole experienceRole}
|
||||
*/
|
||||
AExperienceRole setLevelToRole(AExperienceLevel level, ARole role);
|
||||
List<AExperienceRole> getExperienceRolesAtLevelInServer(AExperienceLevel level, AServer server);
|
||||
|
||||
/**
|
||||
* Deletes *all* (if there are multiple by some chance) roles which were set to be given at the provided {@link AExperienceLevel level} in the {@link AServer server}
|
||||
* @param level The level to remove the roles for
|
||||
* @param server The server in which this should happen
|
||||
*/
|
||||
void removeAllRoleAssignmentsForLevelInServer(AExperienceLevel level, AServer server);
|
||||
void removeAllRoleAssignmentsForLevelInServerExceptRole(AExperienceLevel level, AServer server, ARole role);
|
||||
|
||||
/**
|
||||
* Deletes a singular {@link AExperienceRole experienceRole} directly.
|
||||
|
||||
Reference in New Issue
Block a user