mirror of
https://github.com/Sheldan/abstracto.git
synced 2026-01-19 22:43:31 +00:00
[AB-149] adding command to reset configuration to default values
removing listener to create system config instances adding default value retrieval to appropriate places making config key handling case insensitive changing exp multiplier to double value refactoring experience service bean test
This commit is contained in:
Sheldan
@@ -9,6 +9,7 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
|
||||
import dev.sheldan.abstracto.core.config.FeatureEnum;
|
||||
import dev.sheldan.abstracto.core.service.ConfigService;
|
||||
import dev.sheldan.abstracto.experience.config.features.ExperienceFeature;
|
||||
import dev.sheldan.abstracto.experience.config.features.ExperienceFeatureConfig;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.stereotype.Component;
|
||||
@@ -16,6 +17,7 @@ import org.springframework.stereotype.Component;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
|
||||
/**
|
||||
* Command used to change the experience multiplier on the server.
|
||||
*/
|
||||
@@ -23,8 +25,6 @@ import java.util.List;
|
||||
@Slf4j
|
||||
public class ExpScale extends AbstractConditionableCommand {
|
||||
|
||||
public static final String EXP_MULTIPLIER_KEY = "expMultiplier";
|
||||
|
||||
@Autowired
|
||||
private ConfigService configService;
|
||||
|
||||
@@ -32,7 +32,7 @@ public class ExpScale extends AbstractConditionableCommand {
|
||||
public CommandResult execute(CommandContext commandContext) {
|
||||
Double scale = (Double) commandContext.getParameters().getParameters().get(0);
|
||||
Long guildId = commandContext.getGuild().getIdLong();
|
||||
configService.setDoubleValue(EXP_MULTIPLIER_KEY, guildId, scale);
|
||||
configService.setDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, guildId, scale);
|
||||
log.info("Setting experience scale to {} for {}", scale, guildId);
|
||||
return CommandResult.fromSuccess();
|
||||
}
|
||||
|
||||
@@ -1,33 +0,0 @@
|
||||
package dev.sheldan.abstracto.experience.config;
|
||||
|
||||
import dev.sheldan.abstracto.core.listener.sync.entity.ServerConfigListener;
|
||||
import dev.sheldan.abstracto.core.models.database.AServer;
|
||||
import dev.sheldan.abstracto.core.service.management.ConfigManagementService;
|
||||
import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
|
||||
import dev.sheldan.abstracto.experience.config.features.ExperienceFeatureConfig;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.stereotype.Component;
|
||||
|
||||
/**
|
||||
* Listener responsible to configure the required experience configurations in case the bot joins a new server.
|
||||
*/
|
||||
@Component
|
||||
@Slf4j
|
||||
public class ExperienceConfigListener implements ServerConfigListener {
|
||||
|
||||
|
||||
@Autowired
|
||||
private DefaultConfigManagementService defaultConfigManagementService;
|
||||
|
||||
@Autowired
|
||||
private ConfigManagementService service;
|
||||
|
||||
@Override
|
||||
public void updateServerConfig(AServer server) {
|
||||
log.info("Setting up experience configuration for server {}.", server.getId());
|
||||
service.loadOrCreateIfNotExists(server.getId(), ExperienceFeatureConfig.MIN_EXP_KEY, defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MIN_EXP_KEY).getLongValue());
|
||||
service.loadOrCreateIfNotExists(server.getId(), ExperienceFeatureConfig.MAX_EXP_KEY, defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MAX_EXP_KEY).getLongValue());
|
||||
service.loadOrCreateIfNotExists(server.getId(), ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY).getDoubleValue());
|
||||
}
|
||||
}
|
||||
@@ -4,8 +4,10 @@ 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.models.database.AUserInAServer;
|
||||
import dev.sheldan.abstracto.core.models.property.SystemConfigProperty;
|
||||
import dev.sheldan.abstracto.core.service.*;
|
||||
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
|
||||
import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
|
||||
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
|
||||
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
|
||||
import dev.sheldan.abstracto.core.utils.CompletableFutureList;
|
||||
@@ -80,6 +82,9 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
@Autowired
|
||||
private ChannelManagementService channelManagementService;
|
||||
|
||||
@Autowired
|
||||
private DefaultConfigManagementService defaultConfigManagementService;
|
||||
|
||||
@Autowired
|
||||
private AUserExperienceServiceBean self;
|
||||
|
||||
@@ -169,13 +174,16 @@ public class AUserExperienceServiceBean implements AUserExperienceService {
|
||||
List<ExperienceGainResult> resultFutures = new ArrayList<>();
|
||||
List<CompletableFuture<RoleCalculationResult>> futures = new ArrayList<>();
|
||||
List<AExperienceLevel> levels = experienceLevelManagementService.getLevelConfig();
|
||||
SystemConfigProperty defaultExpMultiplier = defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY);
|
||||
SystemConfigProperty defaultMinExp = defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MIN_EXP_KEY);
|
||||
SystemConfigProperty defaultMaxExp = defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MAX_EXP_KEY);
|
||||
// TODO what if there are a lot in here...., transaction size etc
|
||||
servers.forEach(serverExp -> {
|
||||
AServer server = serverManagementService.loadOrCreate(serverExp.getServerId());
|
||||
log.info("Handling {} experience for server {}", serverExp.getUserInServerIds().size(), serverExp.getServerId());
|
||||
int minExp = configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, serverExp.getServerId()).intValue();
|
||||
int maxExp = configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, serverExp.getServerId()).intValue();
|
||||
Double multiplier = configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverExp.getServerId());
|
||||
int minExp = configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, serverExp.getServerId(), defaultMinExp.getLongValue()).intValue();
|
||||
int maxExp = configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, serverExp.getServerId(), defaultMaxExp.getLongValue()).intValue();
|
||||
Double multiplier = configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverExp.getServerId(), defaultExpMultiplier.getDoubleValue());
|
||||
PrimitiveIterator.OfInt iterator = new Random().ints(serverExp.getUserInServerIds().size(), minExp, maxExp + 1).iterator();
|
||||
levels.sort(Comparator.comparing(AExperienceLevel::getExperienceNeeded));
|
||||
List<AExperienceRole> roles = experienceRoleManagementService.getExperienceRolesForServer(server);
|
||||
|
||||
@@ -3,7 +3,7 @@ abstracto.systemConfigs.minExp.longValue=10
|
||||
abstracto.systemConfigs.maxExp.name=maxExp
|
||||
abstracto.systemConfigs.maxExp.longValue=25
|
||||
abstracto.systemConfigs.expMultiplier.name=expMultiplier
|
||||
abstracto.systemConfigs.expMultiplier.longValue=1
|
||||
abstracto.systemConfigs.expMultiplier.doubleValue=1
|
||||
|
||||
abstracto.featureFlags.experience.featureName=experience
|
||||
abstracto.featureFlags.experience.enabled=false
|
||||
@@ -1,74 +0,0 @@
|
||||
package dev.sheldan.abstracto.experience;
|
||||
|
||||
import dev.sheldan.abstracto.core.models.database.ARole;
|
||||
import dev.sheldan.abstracto.core.models.database.AServer;
|
||||
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
|
||||
import dev.sheldan.abstracto.core.test.MockUtils;
|
||||
import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
|
||||
import dev.sheldan.abstracto.experience.models.database.AExperienceRole;
|
||||
import dev.sheldan.abstracto.experience.models.database.AUserExperience;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.Mockito;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
|
||||
public abstract class ExperienceRelatedTest {
|
||||
|
||||
@Mock
|
||||
private AServer firstServer;
|
||||
|
||||
@Mock
|
||||
private AServer secondServer;
|
||||
|
||||
protected List<AUserExperience> getUserExperiences(int count, AServer server) {
|
||||
List<AUserExperience> experiences = new ArrayList<>();
|
||||
for (int i = 0; i < count; i++) {
|
||||
experiences.add(getUserExperienceObject(server, i));
|
||||
}
|
||||
return experiences;
|
||||
}
|
||||
|
||||
protected AUserExperience getUserExperienceObject(AServer server, long i) {
|
||||
AUserInAServer userObject = MockUtils.getUserObject(i, server);
|
||||
AExperienceLevel level = AExperienceLevel
|
||||
.builder()
|
||||
.level((int)i)
|
||||
.experienceNeeded(i * 100)
|
||||
.build();
|
||||
return AUserExperience
|
||||
.builder()
|
||||
.user(userObject)
|
||||
.experience(i)
|
||||
.currentLevel(level)
|
||||
.build();
|
||||
}
|
||||
|
||||
protected List<AExperienceLevel> getLevelConfiguration() {
|
||||
AExperienceLevel level0 = AExperienceLevel.builder().experienceNeeded(0L).level(0).build();
|
||||
AExperienceLevel level1 = AExperienceLevel.builder().experienceNeeded(100L).level(1).build();
|
||||
AExperienceLevel level2 = AExperienceLevel.builder().experienceNeeded(200L).level(2).build();
|
||||
AExperienceLevel level3 = AExperienceLevel.builder().experienceNeeded(300L).level(3).build();
|
||||
return new ArrayList<>(Arrays.asList(level0, level1, level2, level3));
|
||||
}
|
||||
|
||||
protected List<AExperienceRole> getExperienceRoles(List<AExperienceLevel> levelsWithRoles) {
|
||||
List<AExperienceRole> roles = new ArrayList<>();
|
||||
for (int i = 0; i < levelsWithRoles.size(); i++) {
|
||||
AExperienceLevel level = levelsWithRoles.get(i);
|
||||
ARole role = Mockito.mock(ARole.class);
|
||||
when(role.getId()).thenReturn((long)i);
|
||||
AExperienceRole experienceRole = Mockito.mock(AExperienceRole.class);
|
||||
when(experienceRole.getLevel()).thenReturn(level);
|
||||
when(experienceRole.getId()).thenReturn((long) i);
|
||||
when(experienceRole.getRole()).thenReturn(role);
|
||||
roles.add(experienceRole);
|
||||
}
|
||||
return roles;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -5,6 +5,7 @@ import dev.sheldan.abstracto.core.command.execution.CommandResult;
|
||||
import dev.sheldan.abstracto.core.service.ConfigService;
|
||||
import dev.sheldan.abstracto.core.test.command.CommandConfigValidator;
|
||||
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
|
||||
import dev.sheldan.abstracto.experience.config.features.ExperienceFeatureConfig;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.InjectMocks;
|
||||
@@ -31,7 +32,7 @@ public class ExpScaleTest {
|
||||
CommandContext context = CommandTestUtilities.getWithParameters(Arrays.asList(newScale));
|
||||
CommandResult result = testUnit.execute(context);
|
||||
CommandTestUtilities.checkSuccessfulCompletion(result);
|
||||
verify(configService, times(1)).setDoubleValue(ExpScale.EXP_MULTIPLIER_KEY, context.getGuild().getIdLong(), newScale);
|
||||
verify(configService, times(1)).setDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, context.getGuild().getIdLong(), newScale);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
@@ -1,11 +1,12 @@
|
||||
package dev.sheldan.abstracto.experience.converter;
|
||||
|
||||
import dev.sheldan.abstracto.core.models.database.AServer;
|
||||
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
|
||||
import dev.sheldan.abstracto.core.service.MemberService;
|
||||
import dev.sheldan.abstracto.core.test.MockUtils;
|
||||
import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
|
||||
import dev.sheldan.abstracto.experience.models.LeaderBoard;
|
||||
import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
|
||||
import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
|
||||
import dev.sheldan.abstracto.experience.models.database.AUserExperience;
|
||||
import dev.sheldan.abstracto.experience.models.templates.LeaderBoardEntryModel;
|
||||
import net.dv8tion.jda.api.entities.Member;
|
||||
@@ -25,7 +26,7 @@ import java.util.concurrent.CompletableFuture;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class LeaderBoardModelConverterTest extends ExperienceRelatedTest {
|
||||
public class LeaderBoardModelConverterTest {
|
||||
|
||||
@InjectMocks
|
||||
public LeaderBoardModelConverter testUnit;
|
||||
@@ -79,4 +80,20 @@ public class LeaderBoardModelConverterTest extends ExperienceRelatedTest {
|
||||
AUserExperience firstExperience = getUserExperienceObject(server, experienceParameter);
|
||||
return LeaderBoardEntry.builder().rank(rank).experience(firstExperience).build();
|
||||
}
|
||||
|
||||
private AUserExperience getUserExperienceObject(AServer server, long i) {
|
||||
AUserInAServer userObject = MockUtils.getUserObject(i, server);
|
||||
AExperienceLevel level = AExperienceLevel
|
||||
.builder()
|
||||
.level((int)i)
|
||||
.experienceNeeded(i * 100)
|
||||
.build();
|
||||
return AUserExperience
|
||||
.builder()
|
||||
.user(userObject)
|
||||
.experience(i)
|
||||
.currentLevel(level)
|
||||
.build();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -6,7 +6,6 @@ import dev.sheldan.abstracto.core.models.database.AServer;
|
||||
import dev.sheldan.abstracto.core.models.database.AUser;
|
||||
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
|
||||
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
|
||||
import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
|
||||
import dev.sheldan.abstracto.experience.service.AUserExperienceService;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
@@ -18,7 +17,7 @@ import org.mockito.junit.MockitoJUnitRunner;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class ExperienceTrackerListenerTest extends ExperienceRelatedTest {
|
||||
public class ExperienceTrackerListenerTest {
|
||||
|
||||
@InjectMocks
|
||||
public ExperienceTrackerListener testUnit;
|
||||
|
||||
@@ -3,7 +3,6 @@ package dev.sheldan.abstracto.experience.listener;
|
||||
import dev.sheldan.abstracto.core.models.ServerUser;
|
||||
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
|
||||
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
|
||||
import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
|
||||
import dev.sheldan.abstracto.experience.models.database.AUserExperience;
|
||||
import dev.sheldan.abstracto.experience.service.AUserExperienceService;
|
||||
import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
|
||||
@@ -20,7 +19,7 @@ import java.util.concurrent.CompletableFuture;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class JoiningUserRoleListenerTest extends ExperienceRelatedTest {
|
||||
public class JoiningUserRoleListenerTest {
|
||||
|
||||
@InjectMocks
|
||||
private JoiningUserRoleListener testUnit;
|
||||
|
||||
@@ -1,12 +1,13 @@
|
||||
package dev.sheldan.abstracto.experience.service;
|
||||
|
||||
import dev.sheldan.abstracto.core.models.database.*;
|
||||
import dev.sheldan.abstracto.core.models.property.SystemConfigProperty;
|
||||
import dev.sheldan.abstracto.core.service.*;
|
||||
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
|
||||
import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
|
||||
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
|
||||
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
|
||||
import dev.sheldan.abstracto.core.test.MockUtils;
|
||||
import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
|
||||
import dev.sheldan.abstracto.experience.config.features.ExperienceFeatureConfig;
|
||||
import dev.sheldan.abstracto.experience.models.LeaderBoard;
|
||||
import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
|
||||
@@ -15,6 +16,7 @@ import dev.sheldan.abstracto.experience.models.ServerExperience;
|
||||
import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
|
||||
import dev.sheldan.abstracto.experience.models.database.AExperienceRole;
|
||||
import dev.sheldan.abstracto.experience.models.database.AUserExperience;
|
||||
import dev.sheldan.abstracto.experience.models.database.LeaderBoardEntryResult;
|
||||
import dev.sheldan.abstracto.experience.models.templates.UserSyncStatusModel;
|
||||
import dev.sheldan.abstracto.experience.service.management.DisabledExpRoleManagementService;
|
||||
import dev.sheldan.abstracto.experience.service.management.ExperienceLevelManagementService;
|
||||
@@ -25,6 +27,7 @@ import dev.sheldan.abstracto.core.templating.service.TemplateService;
|
||||
import net.dv8tion.jda.api.entities.Member;
|
||||
import net.dv8tion.jda.api.entities.Message;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.*;
|
||||
@@ -39,7 +42,7 @@ import java.util.concurrent.CompletableFuture;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
public class AUserExperienceServiceBeanTest {
|
||||
|
||||
@InjectMocks
|
||||
private AUserExperienceServiceBean testUnit;
|
||||
@@ -78,19 +81,16 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
private MemberService memberService;
|
||||
|
||||
@Mock
|
||||
private RunTimeExperienceService runTimeExperienceService;
|
||||
private ServerManagementService serverManagementService;
|
||||
|
||||
@Captor
|
||||
private ArgumentCaptor<AUserExperience> aUserExperienceArgumentCaptor;
|
||||
@Mock
|
||||
private UserInServerManagementService userInServerManagementService;
|
||||
|
||||
@Mock
|
||||
private AUserExperienceServiceBean self;
|
||||
|
||||
@Mock
|
||||
private ServerManagementService serverManagementService;
|
||||
|
||||
@Mock
|
||||
private UserInServerManagementService userInServerManagementService;
|
||||
private DefaultConfigManagementService defaultConfigManagementService;
|
||||
|
||||
@Mock
|
||||
private AUserExperience userExperience;
|
||||
@@ -113,9 +113,6 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
@Mock
|
||||
private ServerExperience serverExperience;
|
||||
|
||||
@Mock
|
||||
private ServerExperience serverExperience2;
|
||||
|
||||
@Mock
|
||||
private AServer server;
|
||||
|
||||
@@ -125,48 +122,102 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
@Mock
|
||||
private Member secondMember;
|
||||
|
||||
@Mock
|
||||
private AExperienceLevel level0;
|
||||
|
||||
@Mock
|
||||
private AExperienceLevel level1;
|
||||
|
||||
@Mock
|
||||
private AExperienceLevel level2;
|
||||
|
||||
@Mock
|
||||
private AExperienceLevel level3;
|
||||
|
||||
@Mock
|
||||
private AExperienceRole experienceRole1;
|
||||
|
||||
@Mock
|
||||
private ARole aRole1;
|
||||
|
||||
@Mock
|
||||
private AExperienceRole experienceRole2;
|
||||
|
||||
@Mock
|
||||
private ARole aRole2;
|
||||
|
||||
private List<AExperienceLevel> levels = new ArrayList<>();
|
||||
private List<AExperienceRole> experienceRoles = new ArrayList<>();
|
||||
|
||||
private static final Long USER_IN_SERVER_ID = 4L;
|
||||
private static final Long USER_ID = 8L;
|
||||
private static final Long SERVER_ID = 9L;
|
||||
private static final Long CHANNEL_ID = 7L;
|
||||
private static final Long DEFAULT_MIN_EXP = 10L;
|
||||
private static final Long DEFAULT_MAX_EXP = 25L;
|
||||
private static final Double DEFAULT_EXP_MULTIPLIER = 1D;
|
||||
private static final Long LOW_EXP = 50L;
|
||||
private static final Long MID_EXP = 250L;
|
||||
private static final Long HIGH_EXP = 500L;
|
||||
private static final Long LVL_0_EXP = 0L;
|
||||
private static final Long LVL_1_EXP = 100L;
|
||||
private static final Long LVL_2_EXP = 200L;
|
||||
private static final Long LVL_3_EXP = 300L;
|
||||
private static final Integer ZERO_LVL = 0;
|
||||
private static final Integer SECOND_LVL = 2;
|
||||
|
||||
private static final Long ROLE_ID = 4L;
|
||||
private static final Long SECOND_ROLE_ID = 7L;
|
||||
|
||||
@Before
|
||||
public void setup() {
|
||||
this.levels = Arrays.asList(level0, level1, level2, level3);
|
||||
this.experienceRoles = Arrays.asList(experienceRole1, experienceRole2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCalculateLevelTooLow() {
|
||||
AUserExperience experienceToCalculate = AUserExperience.builder().experience(50L).build();
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, experienceToCalculate.getExperience());
|
||||
Assert.assertEquals(0, calculatedLevel.getLevel().intValue());
|
||||
this.levels = Arrays.asList(level0, level1);
|
||||
setupLevels(1);
|
||||
AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, LOW_EXP);
|
||||
Assert.assertEquals(level0, calculatedLevel);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCalculateLevelBetweenLevels() {
|
||||
AUserExperience experienceToCalculate = AUserExperience.builder().experience(250L).build();
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, experienceToCalculate.getExperience());
|
||||
Assert.assertEquals(2, calculatedLevel.getLevel().intValue());
|
||||
this.levels = Arrays.asList(level0, level1, level2);
|
||||
setupLevels(3);
|
||||
AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, MID_EXP);
|
||||
Assert.assertEquals(level2, calculatedLevel);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCalculateLevelTooHigh() {
|
||||
AUserExperience experienceToCalculate = AUserExperience.builder().experience(500L).build();
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, experienceToCalculate.getExperience());
|
||||
Assert.assertEquals(3, calculatedLevel.getLevel().intValue());
|
||||
this.levels = Arrays.asList(level0, level1, level2, level3);
|
||||
setupLevels(3);
|
||||
AExperienceLevel calculatedLevel = testUnit.calculateLevel(levels, HIGH_EXP);
|
||||
Assert.assertEquals(level3, calculatedLevel);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUpdateUserExperienceLevelChanged() {
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
AUserInAServer userObject = MockUtils.getUserObject(2L, MockUtils.getServer());
|
||||
AUserExperience experienceToCalculate = AUserExperience.builder().user(userObject).currentLevel(levels.get(1)).experience(250L).build();
|
||||
Assert.assertTrue(testUnit.updateUserLevel(experienceToCalculate, levels, experienceToCalculate.getExperience()));
|
||||
AUserExperience experienceToCalculate = Mockito.mock(AUserExperience.class);
|
||||
when(experienceToCalculate.getUser()).thenReturn(aUserInAServer);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(experienceToCalculate.getCurrentLevel()).thenReturn(level0);
|
||||
when(level0.getLevel()).thenReturn(ZERO_LVL);
|
||||
when(level2.getLevel()).thenReturn(SECOND_LVL);
|
||||
setupLevels(3);
|
||||
Assert.assertTrue(testUnit.updateUserLevel(experienceToCalculate, levels, MID_EXP));
|
||||
verify(experienceToCalculate, times(1)).setCurrentLevel(level2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUpdateUserExperienceLevelNotChanged() {
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
AUserInAServer userObject = MockUtils.getUserObject(2L, MockUtils.getServer());
|
||||
AUserExperience experienceToCalculate = AUserExperience.builder().user(userObject).currentLevel(levels.get(2)).experience(250L).build();
|
||||
AUserExperience experienceToCalculate = Mockito.mock(AUserExperience.class);
|
||||
when(experienceToCalculate.getCurrentLevel()).thenReturn(level2);
|
||||
when(experienceToCalculate.getExperience()).thenReturn(MID_EXP);
|
||||
setupLevels(3);
|
||||
Assert.assertFalse(testUnit.updateUserLevel(experienceToCalculate, levels, experienceToCalculate.getExperience()));
|
||||
}
|
||||
|
||||
@@ -176,125 +227,145 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
* In this scenario, the user has a role before, but the config changed, and now there are no experience roles.
|
||||
* Hence the user should lose the experience role.
|
||||
*/
|
||||
List<ServerExperience> servers = Arrays.asList(serverExperience);
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
AExperienceRole previousExperienceRole = experienceRoles.get(1);
|
||||
setupSimpleSingleUserTest(levels, experienceRoles);
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
|
||||
when(roleService.removeRoleFromUserFuture(userExperience.getUser(), userExperience.getCurrentExperienceRole().getRole())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
setupServerId();
|
||||
setupLevels(3);
|
||||
when(experienceRole1.getRole()).thenReturn(aRole1);
|
||||
setExperienceRoleLevels();
|
||||
AExperienceRole previousExperienceRole = experienceRole1;
|
||||
setupServerConfig();
|
||||
setupDefaultConfig();
|
||||
setupLevelsAndRolesAndNoDisallowed();
|
||||
setupUserInServer();
|
||||
when(userExperience.getExperience()).thenReturn(500L);
|
||||
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
|
||||
testUnit.handleExperienceGain(servers).join();
|
||||
verify(roleService, times(1)).removeRoleFromUserFuture(aUserInAServer, previousExperienceRole.getRole());
|
||||
verify(roleService, times(0)).addRoleToUserFuture(eq(aUserInAServer), any());
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
|
||||
when(roleService.removeRoleFromUserFuture(aUserInAServer, aRole1)).thenReturn(CompletableFuture.completedFuture(null));
|
||||
testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
|
||||
verify(roleService, times(1)).removeRoleFromUserFuture(aUserInAServer, aRole1);
|
||||
verify(roleService, times(0)).addRoleToUserFuture(any(AUserInAServer.class), any());
|
||||
verify(self, times(1)).persistExperienceChanges(anyList());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLevelUpGainingNewRoleButUserAlreadyHasRole() {
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
List<ServerExperience> servers = Arrays.asList(serverExperience);
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
AExperienceRole previousExperienceRole = experienceRoles.get(1);
|
||||
setupSimpleSingleUserTest(levels, experienceRoles);
|
||||
setupServerId();
|
||||
setupServerConfig();
|
||||
setupDefaultConfig();
|
||||
setupLevelsAndRolesAndNoDisallowed();
|
||||
when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
setupUserInServer();
|
||||
when(userExperience.getExperience()).thenReturn(199L);
|
||||
AExperienceRole newRole = experienceRoles.get(2);
|
||||
when(experienceRole1.getLevel()).thenReturn(level0);
|
||||
when(experienceRole2.getRole()).thenReturn(aRole2);
|
||||
when(experienceRole2.getLevel()).thenReturn(level1);
|
||||
AExperienceRole newRole = experienceRole2;
|
||||
when(aRole2.getId()).thenReturn(ROLE_ID);
|
||||
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
|
||||
AExperienceRole newAwardedRole = experienceRoles.get(3);
|
||||
when(roleService.memberHasRole(firstMember, newRole.getRole().getId())).thenReturn(true);
|
||||
when(roleService.memberHasRole(firstMember, ROLE_ID)).thenReturn(true);
|
||||
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
|
||||
testUnit.handleExperienceGain(servers).join();
|
||||
verify(roleService, times(0)).addRoleToUser(aUserInAServer, newAwardedRole.getRole());
|
||||
verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, previousExperienceRole.getRole());
|
||||
testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
|
||||
verify(roleService, times(0)).addRoleToUser(any(AUserInAServer.class), any(ARole.class));
|
||||
verify(roleService, times(0)).removeRoleFromUser(any(AUserInAServer.class), any(ARole.class));
|
||||
verify(self, times(1)).persistExperienceChanges(anyList());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLevelUpNotGainingNewRole() {
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
List<ServerExperience> servers = Arrays.asList(serverExperience);
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
AExperienceRole previousExperienceRole = experienceRoles.get(1);
|
||||
setupSimpleSingleUserTest(levels, experienceRoles);
|
||||
AExperienceRole newRole = experienceRoles.get(1);
|
||||
setupServerId();
|
||||
when(experienceRole1.getRole()).thenReturn(aRole1);
|
||||
setExperienceRoleLevels();
|
||||
when(aRole1.getId()).thenReturn(ROLE_ID);
|
||||
setupServerConfig();
|
||||
setupDefaultConfig();
|
||||
setupLevelsAndRolesAndNoDisallowed();
|
||||
when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
setupUserInServer();
|
||||
when(userExperience.getExperience()).thenReturn(500L);
|
||||
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
|
||||
AExperienceRole newRole = experienceRole1;
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(newRole);
|
||||
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
|
||||
|
||||
when(roleService.memberHasRole(firstMember, newRole.getRole().getId())).thenReturn(true);
|
||||
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
|
||||
testUnit.handleExperienceGain(servers).join();
|
||||
verify(roleService, times(0)).addRoleToUser(aUserInAServer, newRole.getRole());
|
||||
verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, previousExperienceRole.getRole());
|
||||
when(roleService.memberHasRole(firstMember, ROLE_ID)).thenReturn(true);
|
||||
testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
|
||||
verify(roleService, times(0)).addRoleToUser(any(AUserInAServer.class), any(ARole.class));
|
||||
verify(roleService, times(0)).removeRoleFromUser(any(AUserInAServer.class), any(ARole.class));
|
||||
verify(self, times(1)).persistExperienceChanges(anyList());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testHandleExperienceForUserNotLevelingUpWithoutExistingRole() {
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
List<ServerExperience> servers = Arrays.asList(serverExperience);
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
AExperienceRole previousExperienceRole = null;
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
|
||||
setupSimpleSingleUserTest(levels, experienceRoles);
|
||||
when(memberService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
|
||||
AExperienceRole newRole = experienceRoles.get(1);
|
||||
setupServerId();
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(null);
|
||||
setupServerConfig();
|
||||
setupDefaultConfig();
|
||||
setupLevelsAndRolesAndNoDisallowed();
|
||||
when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
setupUserInServer();
|
||||
when(userExperience.getExperience()).thenReturn(500L);
|
||||
AExperienceRole newRole = experienceRole1;
|
||||
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
|
||||
|
||||
when(roleService.memberHasRole(firstMember, newRole.getRole().getId())).thenReturn(false);
|
||||
when(roleService.addRoleToMemberFuture(firstMember, newRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
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(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
|
||||
when(roleService.addRoleToMemberFuture(firstMember, newRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
testUnit.handleExperienceGain(servers).join();
|
||||
when(roleService.addRoleToMemberFuture(firstMember, ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
|
||||
CompletableFuture<Void> future = testUnit.handleExperienceGain(Arrays.asList(serverExperience));
|
||||
future.join();
|
||||
Assert.assertFalse(future.isCompletedExceptionally());
|
||||
verify(roleService, times(0)).addRoleToUserFuture(any(AUserInAServer.class), any(ARole.class));
|
||||
verify(self, times(1)).persistExperienceChanges(anyList());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void handleExpGainWithTooLittleForRole() {
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
List<ServerExperience> servers = Arrays.asList(serverExperience);
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
AExperienceRole previousExperienceRole = null;
|
||||
setupSimpleSingleUserTest(levels, experienceRoles);
|
||||
setupServerId();
|
||||
setupServerConfig();
|
||||
setupDefaultConfig();
|
||||
setupLevelsAndRolesAndNoDisallowed();
|
||||
setupUserInServer();
|
||||
when(userExperience.getExperience()).thenReturn(50L);
|
||||
setExperienceRoleLevels();
|
||||
when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
|
||||
when(memberService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
|
||||
AExperienceRole newRole = null;
|
||||
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(null);
|
||||
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(null);
|
||||
|
||||
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
|
||||
testUnit.handleExperienceGain(servers).join();
|
||||
testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
|
||||
verify(roleService, times(0)).removeRoleFromUserFuture(eq(aUserInAServer), any());
|
||||
verify(roleService, times(0)).addRoleToUserFuture(eq(aUserInAServer), any());
|
||||
verify(self, times(1)).persistExperienceChanges(anyList());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUserHasExperienceRoleButNotAnymore() {
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
List<ServerExperience> servers = Arrays.asList(serverExperience);
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
setupSimpleSingleUserTest(levels, experienceRoles);
|
||||
setupServerId();
|
||||
setupServerConfig();
|
||||
setupDefaultConfig();
|
||||
setupLevelsAndRolesAndNoDisallowed();
|
||||
setupUserInServer();
|
||||
when(userExperience.getExperience()).thenReturn(50L);
|
||||
when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
|
||||
AExperienceRole previousExperienceRole = experienceRoles.get(0);
|
||||
AExperienceRole previousExperienceRole = experienceRole1;
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(previousExperienceRole);
|
||||
when(memberService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
|
||||
AExperienceRole newRole = null;
|
||||
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(newRole);
|
||||
when(experienceRole1.getRole()).thenReturn(aRole1);
|
||||
setExperienceRoleLevels();
|
||||
when(experienceRoleService.calculateRole(eq(experienceRoles), any())).thenReturn(null);
|
||||
|
||||
when(roleService.removeRoleFromUserFuture(eq(aUserInAServer), any())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
|
||||
testUnit.handleExperienceGain(servers).join();
|
||||
testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
|
||||
verify(roleService, times(0)).addRoleToUserFuture(eq(aUserInAServer), any());
|
||||
verify(roleService, times(1)).removeRoleFromUserFuture(eq(aUserInAServer), any());
|
||||
verify(self, times(1)).persistExperienceChanges(anyList());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testHandleExperienceGainForGainDisabledForUser() {
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
List<ServerExperience> servers = Arrays.asList(serverExperience);
|
||||
setupServerId();
|
||||
setupServerConfig();
|
||||
when(serverManagementService.loadOrCreate(serverExperience.getServerId())).thenReturn(server);
|
||||
when(experienceLevelManagementService.getLevelConfig()).thenReturn(levels);
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
|
||||
when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(new ArrayList<>());
|
||||
setupDefaultConfig();
|
||||
setupLevelsAndRolesAndNoDisallowed();
|
||||
setExperienceRoleLevels();
|
||||
when(userInServerManagementService.loadOrCreateUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
|
||||
@@ -302,84 +373,86 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
when(userExperience.getExperienceGainDisabled()).thenReturn(true);
|
||||
|
||||
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
|
||||
testUnit.handleExperienceGain(servers).join();
|
||||
testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
|
||||
verify(roleService, times(0)).removeRoleFromUserFuture(eq(aUserInAServer), any());
|
||||
verify(roleService, times(0)).addRoleToUserFuture(eq(aUserInAServer), any());
|
||||
verify(self, times(1)).persistExperienceChanges(anyList());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testHandleExperienceGainForGainDisabledForRole() {
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
List<ServerExperience> servers = Arrays.asList(serverExperience);
|
||||
ServerExperience serverToUse = servers.get(0);
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
mockSimpleServer(levels, experienceRoles, serverToUse);
|
||||
testUnit.handleExperienceGain(servers).join();
|
||||
verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, experienceRoles.get(0).getRole());
|
||||
setupServerId();
|
||||
when(userInServerManagementService.loadOrCreateUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
|
||||
when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
|
||||
setupServerConfig();
|
||||
setupDefaultConfig();
|
||||
setupLevelsAndRolesAndNoDisallowed();
|
||||
setExperienceRoleLevels();
|
||||
testUnit.handleExperienceGain(Arrays.asList(serverExperience)).join();
|
||||
verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, aRole1);
|
||||
verify(roleService, times(0)).addRoleToUser(eq(aUserInAServer), any(ARole.class));
|
||||
verify(self, times(1)).persistExperienceChanges(anyList());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testHandleExperienceForUserNotLevelingUpWithExistingRole() {
|
||||
List<AExperienceLevel> levels = getLevelConfiguration();
|
||||
List<ServerExperience> servers = Arrays.asList(serverExperience);
|
||||
setupServerId();
|
||||
when(userInServerManagementService.loadOrCreateUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
|
||||
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
|
||||
when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
|
||||
ServerExperience serverToUse = servers.get(0);
|
||||
List<AExperienceRole> experienceRoles = getExperienceRoles(levels);
|
||||
mockSimpleServer(levels, experienceRoles, serverExperience);
|
||||
Long userToUse = serverToUse.getUserInServerIds().get(0);
|
||||
when(userExperienceManagementService.findByUserInServerIdOptional(userToUse)).thenReturn(Optional.of(userExperience));
|
||||
when(userExperience.getUser()).thenReturn(aUserInAServer);
|
||||
when(userInServerManagementService.loadOrCreateUser(userToUse)).thenReturn(aUserInAServer);
|
||||
when(memberService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(server.getId()).thenReturn(8L);
|
||||
when(memberService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
|
||||
when(roleService.hasAnyOfTheRoles(eq(firstMember), anyList())).thenReturn(false);
|
||||
when(user.getId()).thenReturn(7L);
|
||||
CompletableFuture<Void> future = testUnit.handleExperienceGain(servers);
|
||||
when(user.getId()).thenReturn(USER_ID);
|
||||
setExperienceRoleLevels();
|
||||
|
||||
setupServerConfig();
|
||||
setupDefaultConfig();
|
||||
setupLevelsAndRolesAndNoDisallowed();
|
||||
|
||||
CompletableFuture<Void> future = testUnit.handleExperienceGain(Arrays.asList(serverExperience));
|
||||
future.join();
|
||||
verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, experienceRoles.get(0).getRole());
|
||||
verify(roleService, times(0)).removeRoleFromUser(aUserInAServer, aRole1);
|
||||
verify(roleService, times(0)).addRoleToUser(eq(aUserInAServer), any(ARole.class));
|
||||
verify(self, times(1)).persistExperienceChanges(anyList());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSyncNoRoleUserGettingRole2() {
|
||||
AExperienceLevel level0 = Mockito.mock(AExperienceLevel.class);
|
||||
AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
|
||||
userExperience.setCurrentExperienceRole(null);
|
||||
AExperienceRole afterRole = usedExperienceRoles.get(0);
|
||||
AExperienceRole afterRole = experienceRole1;
|
||||
when(experienceRole1.getRole()).thenReturn(aRole1);
|
||||
when(experienceRole1.getId()).thenReturn(ROLE_ID);
|
||||
when(aRole1.getId()).thenReturn(ROLE_ID);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(userExperience.getUser()).thenReturn(aUserInAServer);
|
||||
|
||||
when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
|
||||
when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
|
||||
when(experienceRoleService.calculateRole(experienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(memberService.getMemberInServerAsync(userExperience.getUser())).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
when(roleService.addRoleToMemberFuture(firstMember, afterRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(roleService.addRoleToMemberFuture(firstMember, ROLE_ID)).thenReturn(CompletableFuture.completedFuture(null));
|
||||
CompletableFuture<RoleCalculationResult> calculationFuture = testUnit.syncForSingleUser(userExperience);
|
||||
RoleCalculationResult result = calculationFuture.join();
|
||||
Assert.assertEquals(afterRole.getRole().getId(), result.getExperienceRoleId());
|
||||
Assert.assertEquals(ROLE_ID, result.getExperienceRoleId());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSyncUserLosingRole() {
|
||||
AExperienceLevel level0 = Mockito.mock(AExperienceLevel.class);
|
||||
AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
|
||||
AExperienceRole beforeRole = usedExperienceRoles.get(0);
|
||||
AExperienceRole beforeRole = experienceRole1;
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(beforeRole);
|
||||
AExperienceRole afterRole = null;
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(userExperience.getUser()).thenReturn(aUserInAServer);
|
||||
when(experienceRole1.getRole()).thenReturn(aRole1);
|
||||
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
|
||||
when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(roleService.removeRoleFromUserFuture(aUserInAServer, beforeRole.getRole())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
|
||||
when(experienceRoleService.calculateRole(experienceRoles, userExperience.getLevelOrDefault())).thenReturn(null);
|
||||
when(roleService.removeRoleFromUserFuture(aUserInAServer, aRole1)).thenReturn(CompletableFuture.completedFuture(null));
|
||||
CompletableFuture<RoleCalculationResult> calculationFuture = testUnit.syncForSingleUser(userExperience);
|
||||
RoleCalculationResult result = calculationFuture.join();
|
||||
Assert.assertNull(result.getExperienceRoleId());
|
||||
@@ -387,87 +460,74 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
|
||||
@Test
|
||||
public void testSyncUserKeepingRole() {
|
||||
AExperienceLevel level0 = Mockito.mock(AExperienceLevel.class);
|
||||
AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
|
||||
AExperienceRole beforeRole = usedExperienceRoles.get(0);
|
||||
AExperienceRole beforeRole = experienceRole1;
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(beforeRole);
|
||||
AExperienceRole afterRole = usedExperienceRoles.get(0);
|
||||
AExperienceRole afterRole = experienceRole1;
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(userExperience.getUser()).thenReturn(aUserInAServer);
|
||||
|
||||
when(aRole1.getId()).thenReturn(ROLE_ID);
|
||||
when(experienceRole1.getId()).thenReturn(ROLE_ID);
|
||||
when(experienceRole1.getRole()).thenReturn(aRole1);
|
||||
when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
|
||||
when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
|
||||
when(experienceRoleService.calculateRole(experienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(memberService.getMemberInServerAsync(userExperience.getUser())).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
when(roleService.memberHasRole(firstMember, afterRole.getRole().getId())).thenReturn(true);
|
||||
when(roleService.memberHasRole(firstMember, ROLE_ID)).thenReturn(true);
|
||||
CompletableFuture<RoleCalculationResult> calculationFuture = testUnit.syncForSingleUser(userExperience);
|
||||
RoleCalculationResult result = calculationFuture.join();
|
||||
Assert.assertEquals(afterRole.getRole().getId(), result.getExperienceRoleId());
|
||||
Assert.assertEquals(ROLE_ID, result.getExperienceRoleId());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSyncUserChangingRole() {
|
||||
AExperienceLevel level0 = Mockito.mock(AExperienceLevel.class);
|
||||
AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
|
||||
AExperienceRole beforeRole = usedExperienceRoles.get(0);
|
||||
AExperienceRole beforeRole = experienceRole1;
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(beforeRole);
|
||||
AExperienceRole afterRole = usedExperienceRoles.get(1);
|
||||
AExperienceRole afterRole = experienceRole2;
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(userExperience.getUser()).thenReturn(aUserInAServer);
|
||||
when(roleService.memberHasRole(firstMember, beforeRole.getRole().getId())).thenReturn(true);
|
||||
|
||||
when(aRole1.getId()).thenReturn(ROLE_ID);
|
||||
when(aRole2.getId()).thenReturn(SECOND_ROLE_ID);
|
||||
when(experienceRole1.getRole()).thenReturn(aRole1);
|
||||
when(experienceRole2.getRole()).thenReturn(aRole2);
|
||||
when(experienceRole2.getId()).thenReturn(SECOND_ROLE_ID);
|
||||
|
||||
when(roleService.memberHasRole(firstMember, ROLE_ID)).thenReturn(true);
|
||||
|
||||
when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
|
||||
when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(memberService.getMemberInServerAsync(userExperience.getUser())).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
when(roleService.memberHasRole(firstMember, afterRole.getRole().getId())).thenReturn(false);
|
||||
when(roleService.removeRoleFromMemberAsync(firstMember, beforeRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(roleService.addRoleToMemberFuture(firstMember, afterRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
|
||||
when(experienceRoleService.calculateRole(experienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
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));
|
||||
CompletableFuture<RoleCalculationResult> calculationFuture = testUnit.syncForSingleUser(userExperience);
|
||||
RoleCalculationResult result = calculationFuture.join();
|
||||
Assert.assertEquals(afterRole.getRole().getId(), result.getExperienceRoleId());
|
||||
Assert.assertEquals(SECOND_ROLE_ID, result.getExperienceRoleId());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDisablingExperienceForUser() {
|
||||
AUserInAServer userObject = MockUtils.getUserObject(2L, server);
|
||||
AUserExperience experience = AUserExperience.builder().user(userObject).experienceGainDisabled(false).build();
|
||||
when(userExperienceManagementService.findUserInServer(userObject)).thenReturn(experience);
|
||||
testUnit.disableExperienceForUser(userObject);
|
||||
Assert.assertTrue(experience.getExperienceGainDisabled());
|
||||
AUserExperience experience = Mockito.mock(AUserExperience.class);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(experience);
|
||||
testUnit.disableExperienceForUser(aUserInAServer);
|
||||
verify(experience, times(1)).setExperienceGainDisabled(true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDisablingExpForUserWhichHasItDisabled() {
|
||||
AUserInAServer userObject = MockUtils.getUserObject(2L, server);
|
||||
AUserExperience experience = AUserExperience.builder().user(userObject).experienceGainDisabled(true).build();
|
||||
when(userExperienceManagementService.findUserInServer(userObject)).thenReturn(experience);
|
||||
testUnit.disableExperienceForUser(userObject);
|
||||
Assert.assertTrue(experience.getExperienceGainDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEnablingExperienceForEnabledUser() {
|
||||
AUserInAServer userObject = MockUtils.getUserObject(2L, server);
|
||||
AUserExperience experience = AUserExperience.builder().user(userObject).experienceGainDisabled(false).build();
|
||||
when(userExperienceManagementService.findUserInServer(userObject)).thenReturn(experience);
|
||||
testUnit.enableExperienceForUser(userObject);
|
||||
Assert.assertFalse(experience.getExperienceGainDisabled());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testEnablingExpForUserWhichHasItDisabled() {
|
||||
AUserInAServer userObject = MockUtils.getUserObject(2L, server);
|
||||
AUserExperience experience = AUserExperience.builder().user(userObject).experienceGainDisabled(true).build();
|
||||
when(userExperienceManagementService.findUserInServer(userObject)).thenReturn(experience);
|
||||
testUnit.enableExperienceForUser(userObject);
|
||||
Assert.assertFalse(experience.getExperienceGainDisabled());
|
||||
public void testEnablingExpForUser() {
|
||||
AUserExperience experience = Mockito.mock(AUserExperience.class);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(experience);
|
||||
testUnit.enableExperienceForUser(aUserInAServer);
|
||||
verify(experience, times(1)).setExperienceGainDisabled(false);
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -482,18 +542,15 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void testIllegalLeaderBoardPage() {
|
||||
testUnit.findLeaderBoardData(MockUtils.getServer(1L), -1);
|
||||
testUnit.findLeaderBoardData(server, -1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSyncAllUsers() {
|
||||
AExperienceLevel level0 = Mockito.mock(AExperienceLevel.class);
|
||||
AExperienceLevel level1 = Mockito.mock(AExperienceLevel.class);
|
||||
List<AExperienceRole> usedExperienceRoles = getExperienceRoles(Arrays.asList(level0, level1));
|
||||
AExperienceRole beforeRole = usedExperienceRoles.get(0);
|
||||
AExperienceRole beforeRole = experienceRole1;
|
||||
|
||||
when(userExperience.getCurrentExperienceRole()).thenReturn(beforeRole);
|
||||
AExperienceRole afterRole = usedExperienceRoles.get(1);
|
||||
AExperienceRole afterRole = experienceRole2;
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(user.getId()).thenReturn(8L);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
@@ -511,78 +568,65 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
when(memberService.getMemberInServerAsync(aUserInAServer2)).thenReturn(CompletableFuture.completedFuture(secondMember));
|
||||
|
||||
when(server.getId()).thenReturn(15L);
|
||||
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(usedExperienceRoles);
|
||||
when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(experienceRoleService.calculateRole(usedExperienceRoles, userExperience2.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(memberService.getMemberInServerAsync(userExperience.getUser())).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
when(memberService.getMemberInServerAsync(userExperience2.getUser())).thenReturn(CompletableFuture.completedFuture(secondMember));
|
||||
when(roleService.memberHasRole(firstMember, afterRole.getRole().getId())).thenReturn(false);
|
||||
when(roleService.memberHasRole(firstMember, beforeRole.getRole().getId())).thenReturn(true);
|
||||
when(roleService.memberHasRole(secondMember, afterRole.getRole().getId())).thenReturn(true);
|
||||
when(roleService.removeRoleFromMemberAsync(firstMember, beforeRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(roleService.addRoleToMemberFuture(firstMember, afterRole.getRole().getId())).thenReturn(CompletableFuture.completedFuture(null));
|
||||
when(aRole1.getId()).thenReturn(ROLE_ID);
|
||||
when(aRole2.getId()).thenReturn(SECOND_ROLE_ID);
|
||||
when(experienceRole1.getRole()).thenReturn(aRole1);
|
||||
when(experienceRole2.getRole()).thenReturn(aRole2);
|
||||
when(experienceRole2.getId()).thenReturn(SECOND_ROLE_ID);
|
||||
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
|
||||
when(experienceRoleService.calculateRole(experienceRoles, userExperience.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(experienceRoleService.calculateRole(experienceRoles, userExperience2.getLevelOrDefault())).thenReturn(afterRole);
|
||||
when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
when(memberService.getMemberInServerAsync(aUserInAServer2)).thenReturn(CompletableFuture.completedFuture(secondMember));
|
||||
when(roleService.memberHasRole(firstMember, SECOND_ROLE_ID)).thenReturn(false);
|
||||
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));
|
||||
List<AUserExperience> experiences = Arrays.asList(userExperience, userExperience2);
|
||||
when(userExperienceManagementService.loadAllUsers(server)).thenReturn(experiences);
|
||||
List<CompletableFuture<RoleCalculationResult>> calculationFutures = testUnit.syncUserRoles(server);
|
||||
verify(roleService, times(0)).removeRoleFromMemberAsync(secondMember, beforeRole.getRole().getId());
|
||||
verify(roleService, times(0)).addRoleToMemberFuture(secondMember, afterRole.getRole().getId());
|
||||
verify(roleService, times(0)).removeRoleFromMemberAsync(secondMember, ROLE_ID);
|
||||
verify(roleService, times(0)).addRoleToMemberFuture(secondMember, SECOND_ROLE_ID);
|
||||
RoleCalculationResult firstResult = calculationFutures.get(0).join();
|
||||
Assert.assertEquals(afterRole.getRole().getId(), firstResult.getExperienceRoleId());
|
||||
Assert.assertEquals(SECOND_ROLE_ID, firstResult.getExperienceRoleId());
|
||||
RoleCalculationResult secondResult = calculationFutures.get(1).join();
|
||||
Assert.assertEquals(afterRole.getRole().getId(), secondResult.getExperienceRoleId());
|
||||
Assert.assertEquals(SECOND_ROLE_ID, secondResult.getExperienceRoleId());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetRankForUser() {
|
||||
long experience = 1L;
|
||||
int level = 1;
|
||||
long messageCount = 1L;
|
||||
int rank = 1;
|
||||
AUserInAServer userInAServer = MockUtils.getUserObject(1L, server);
|
||||
AExperienceLevel level0 = AExperienceLevel.builder().experienceNeeded(200L).level(level).build();
|
||||
AUserExperience experienceObj = AUserExperience.builder().experience(experience).user(MockUtils.getUserObject(3L, server)).currentLevel(level0).build();
|
||||
when(userExperienceManagementService.findUserInServer(userInAServer)).thenReturn(experienceObj);
|
||||
LeaderBoardEntryTestImpl leaderBoardEntryTest = LeaderBoardEntryTestImpl
|
||||
.builder()
|
||||
.experience(experience)
|
||||
.id(1L)
|
||||
.level(level)
|
||||
.messageCount(messageCount)
|
||||
.rank(rank)
|
||||
.userInServerId(1L)
|
||||
.build();
|
||||
AUserExperience experienceObj = Mockito.mock(AUserExperience.class);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(experienceObj);
|
||||
LeaderBoardEntryResult leaderBoardEntryTest = Mockito.mock(LeaderBoardEntryResult.class);
|
||||
when(leaderBoardEntryTest.getRank()).thenReturn(rank);
|
||||
when(userExperienceManagementService.getRankOfUserInServer(experienceObj)).thenReturn(leaderBoardEntryTest);
|
||||
LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(userInAServer);
|
||||
Assert.assertEquals(experience, rankOfUserInServer.getExperience().getExperience().longValue());
|
||||
Assert.assertEquals(level, rankOfUserInServer.getExperience().getCurrentLevel().getLevel().intValue());
|
||||
LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(aUserInAServer);
|
||||
Assert.assertEquals(experienceObj, rankOfUserInServer.getExperience());
|
||||
Assert.assertEquals(rank, rankOfUserInServer.getRank().intValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetRankForUserNotExisting() {
|
||||
AUserInAServer userInAServer = MockUtils.getUserObject(1L, server);
|
||||
when(userExperienceManagementService.findUserInServer(userInAServer)).thenReturn(null);
|
||||
LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(userInAServer);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(null);
|
||||
LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(aUserInAServer);
|
||||
Assert.assertNull(rankOfUserInServer.getExperience());
|
||||
Assert.assertEquals(0, rankOfUserInServer.getRank().intValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetRankWhenRankReturnsNull() {
|
||||
long experience = 1L;
|
||||
int level = 1;
|
||||
long messageCount = 1L;
|
||||
AUserInAServer userInAServer = MockUtils.getUserObject(1L, server);
|
||||
AExperienceLevel level0 = AExperienceLevel.builder().experienceNeeded(200L).level(level).build();
|
||||
AUserExperience experienceObj = AUserExperience.builder().experience(experience).user(MockUtils.getUserObject(3L, server)).messageCount(messageCount).currentLevel(level0).build();
|
||||
when(userExperienceManagementService.findUserInServer(userInAServer)).thenReturn(experienceObj);
|
||||
AUserExperience experienceObj = Mockito.mock(AUserExperience.class);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(experienceObj);
|
||||
when(userExperienceManagementService.getRankOfUserInServer(experienceObj)).thenReturn(null);
|
||||
LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(userInAServer);
|
||||
Assert.assertEquals(experience, rankOfUserInServer.getExperience().getExperience().longValue());
|
||||
Assert.assertEquals(level, rankOfUserInServer.getExperience().getCurrentLevel().getLevel().intValue());
|
||||
Assert.assertEquals(messageCount, rankOfUserInServer.getExperience().getMessageCount().longValue());
|
||||
LeaderBoardEntry rankOfUserInServer = testUnit.getRankOfUserInServer(aUserInAServer);
|
||||
Assert.assertEquals(experienceObj, rankOfUserInServer.getExperience());
|
||||
Assert.assertEquals(0, rankOfUserInServer.getRank().intValue());
|
||||
}
|
||||
|
||||
@@ -591,7 +635,7 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
AChannel channel = Mockito.mock(AChannel.class);
|
||||
when(channel.getServer()).thenReturn(server);
|
||||
when(server.getId()).thenReturn(SERVER_ID);
|
||||
List<AUserExperience> experiences = getUserExperiences(25, server);
|
||||
List<AUserExperience> experiences = getUserExperiences(25);
|
||||
|
||||
checkStatusMessages(server, channel, experiences, 13);
|
||||
}
|
||||
@@ -605,35 +649,9 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
checkStatusMessages(server, channel, experiences, 1);
|
||||
}
|
||||
|
||||
private void setupServerConfig() {
|
||||
when(configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, serverExperience.getServerId())).thenReturn(20L);
|
||||
when(configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, serverExperience.getServerId())).thenReturn(50L);
|
||||
when(configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverExperience.getServerId())).thenReturn(1.2);
|
||||
}
|
||||
|
||||
private void setupSimpleSingleUserTest(List<AExperienceLevel> levels, List<AExperienceRole> experienceRoles) {
|
||||
setupServerConfig();
|
||||
when(serverManagementService.loadOrCreate(serverExperience.getServerId())).thenReturn(server);
|
||||
when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
|
||||
when(experienceLevelManagementService.getLevelConfig()).thenReturn(levels);
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
|
||||
when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(new ArrayList<>());
|
||||
when(userInServerManagementService.loadOrCreateUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
|
||||
when(user.getId()).thenReturn(USER_ID);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(memberService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
|
||||
when(memberService.getMemberInServerAsync(aUserInAServer)).thenReturn(CompletableFuture.completedFuture(firstMember));
|
||||
when(userExperience.getExperience()).thenReturn(500L);
|
||||
when(userExperience.getUser()).thenReturn(aUserInAServer);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(server.getId()).thenReturn(SERVER_ID);
|
||||
when(user.getId()).thenReturn(USER_ID);
|
||||
}
|
||||
|
||||
private void checkStatusMessages(AServer server, AChannel channel, List<AUserExperience> experiences, int messageCount) {
|
||||
when(userExperienceManagementService.loadAllUsers(server)).thenReturn(experiences);
|
||||
MessageToSend statusMessage = MessageToSend.builder().message("text").build();
|
||||
MessageToSend statusMessage = Mockito.mock(MessageToSend.class);
|
||||
when(templateService.renderEmbedTemplate(eq("user_sync_status_message"), any(UserSyncStatusModel.class), eq(SERVER_ID))).thenReturn(statusMessage);
|
||||
long messageId = 5L;
|
||||
Message statusMessageJDA = Mockito.mock(Message.class);
|
||||
@@ -644,32 +662,109 @@ public class AUserExperienceServiceBeanTest extends ExperienceRelatedTest {
|
||||
verify(messageService, times(messageCount)).updateStatusMessage(channel, messageId, statusMessage);
|
||||
}
|
||||
|
||||
private void setupUserInServer() {
|
||||
when(userExperienceManagementService.findByUserInServerIdOptional(USER_IN_SERVER_ID)).thenReturn(Optional.of(userExperience));
|
||||
when(serverExperience.getUserInServerIds()).thenReturn(Arrays.asList(USER_IN_SERVER_ID));
|
||||
when(userInServerManagementService.loadOrCreateUser(USER_IN_SERVER_ID)).thenReturn(aUserInAServer);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
when(memberService.getMemberInServer(aUserInAServer)).thenReturn(firstMember);
|
||||
when(userExperience.getUser()).thenReturn(aUserInAServer);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(user.getId()).thenReturn(USER_ID);
|
||||
}
|
||||
|
||||
private void setupTwoExperienceRoles() {
|
||||
when(experienceRole1.getRole()).thenReturn(aRole1);
|
||||
setExperienceRoleLevels();
|
||||
}
|
||||
|
||||
private void setupServerId() {
|
||||
when(server.getId()).thenReturn(SERVER_ID);
|
||||
when(serverExperience.getServerId()).thenReturn(SERVER_ID);
|
||||
when(serverManagementService.loadOrCreate(SERVER_ID)).thenReturn(server);
|
||||
}
|
||||
|
||||
private void setupServerConfig() {
|
||||
when(configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, SERVER_ID, DEFAULT_MIN_EXP)).thenReturn(20L);
|
||||
when(configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, SERVER_ID, DEFAULT_MAX_EXP)).thenReturn(50L);
|
||||
when(configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, SERVER_ID, DEFAULT_EXP_MULTIPLIER)).thenReturn(1.2);
|
||||
}
|
||||
|
||||
private void executeLeaderBoardTest(AServer server, Integer page) {
|
||||
int pageSize = 10;
|
||||
List<AUserExperience> experiences = getUserExperiences(pageSize, server);
|
||||
List<AUserExperience> experiences = Arrays.asList(userExperience, userExperience2);
|
||||
when(userExperience.getExperience()).thenReturn(LOW_EXP);
|
||||
when(userExperience.getCurrentLevel()).thenReturn(level0);
|
||||
when(userExperience.getUser()).thenReturn(aUserInAServer);
|
||||
when(userExperience2.getExperience()).thenReturn(MID_EXP);
|
||||
when(userExperience2.getCurrentLevel()).thenReturn(level1);
|
||||
when(userExperience2.getUser()).thenReturn(aUserInAServer2);
|
||||
when(userExperienceManagementService.findLeaderBoardUsersPaginated(server, (page - 1) * pageSize, page * pageSize)).thenReturn(experiences);
|
||||
LeaderBoard leaderBoardData = testUnit.findLeaderBoardData(server, page);
|
||||
page--;
|
||||
List<LeaderBoardEntry> entries = leaderBoardData.getEntries();
|
||||
for (int i = 0; i < entries.size(); i++) {
|
||||
LeaderBoardEntry entry = entries.get(i);
|
||||
Assert.assertEquals(i, entry.getExperience().getExperience().longValue());
|
||||
Assert.assertEquals(i, entry.getExperience().getCurrentLevel().getLevel().intValue());
|
||||
Assert.assertEquals(i, entry.getExperience().getUser().getUserReference().getId().longValue());
|
||||
Assert.assertEquals((page * pageSize) + i + 1, entry.getRank().intValue());
|
||||
}
|
||||
Assert.assertEquals(pageSize, entries.size());
|
||||
LeaderBoardEntry firstEntry = entries.get(0);
|
||||
Assert.assertEquals(LOW_EXP, firstEntry.getExperience().getExperience());
|
||||
Assert.assertEquals(level0, firstEntry.getExperience().getCurrentLevel());
|
||||
Assert.assertEquals(aUserInAServer, firstEntry.getExperience().getUser());
|
||||
Assert.assertEquals((page * pageSize) + 1, firstEntry.getRank().intValue());
|
||||
LeaderBoardEntry secondEntry = entries.get(1);
|
||||
Assert.assertEquals(MID_EXP, secondEntry.getExperience().getExperience());
|
||||
Assert.assertEquals(level1, secondEntry.getExperience().getCurrentLevel());
|
||||
Assert.assertEquals(aUserInAServer2, secondEntry.getExperience().getUser());
|
||||
Assert.assertEquals((page * pageSize) + 2, secondEntry.getRank().intValue());
|
||||
Assert.assertEquals(2, entries.size());
|
||||
}
|
||||
|
||||
private void mockSimpleServer(List<AExperienceLevel> levels, List<AExperienceRole> experienceRoles, ServerExperience serverExperience) {
|
||||
when(configService.getLongValue(ExperienceFeatureConfig.MIN_EXP_KEY, serverExperience.getServerId())).thenReturn(20L);
|
||||
when(configService.getLongValue(ExperienceFeatureConfig.MAX_EXP_KEY, serverExperience.getServerId())).thenReturn(50L);
|
||||
when(configService.getDoubleValue(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY, serverExperience.getServerId())).thenReturn(1.2);
|
||||
when(serverManagementService.loadOrCreate(serverExperience.getServerId())).thenReturn(server);
|
||||
private void setExperienceRoleLevels() {
|
||||
when(experienceRole1.getLevel()).thenReturn(level0);
|
||||
when(experienceRole2.getLevel()).thenReturn(level1);
|
||||
}
|
||||
|
||||
private void setupLevelsAndRolesAndNoDisallowed() {
|
||||
when(experienceLevelManagementService.getLevelConfig()).thenReturn(levels);
|
||||
when(experienceRoleManagementService.getExperienceRolesForServer(server)).thenReturn(experienceRoles);
|
||||
when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(new ArrayList<>());
|
||||
}
|
||||
|
||||
private void setupDefaultConfig() {
|
||||
SystemConfigProperty minExpProperty = Mockito.mock(SystemConfigProperty.class);
|
||||
when(minExpProperty.getLongValue()).thenReturn(DEFAULT_MIN_EXP);
|
||||
when(defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MIN_EXP_KEY)).thenReturn(minExpProperty);
|
||||
SystemConfigProperty maxExpProperty = Mockito.mock(SystemConfigProperty.class);
|
||||
when(maxExpProperty.getLongValue()).thenReturn(DEFAULT_MAX_EXP);
|
||||
when(defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.MAX_EXP_KEY)).thenReturn(maxExpProperty);
|
||||
SystemConfigProperty expMultiplierProperty = Mockito.mock(SystemConfigProperty.class);
|
||||
when(expMultiplierProperty.getDoubleValue()).thenReturn(DEFAULT_EXP_MULTIPLIER);
|
||||
when(defaultConfigManagementService.getDefaultConfig(ExperienceFeatureConfig.EXP_MULTIPLIER_KEY)).thenReturn(expMultiplierProperty);
|
||||
}
|
||||
|
||||
protected List<AUserExperience> getUserExperiences(int count) {
|
||||
List<AUserExperience> experiences = new ArrayList<>();
|
||||
for (int i = 0; i < count; i++) {
|
||||
AUserExperience experience = Mockito.mock(AUserExperience.class);
|
||||
when(experience.getUser()).thenReturn(aUserInAServer);
|
||||
when(aUserInAServer.getServerReference()).thenReturn(server);
|
||||
when(aUserInAServer.getUserReference()).thenReturn(user);
|
||||
experiences.add(experience);
|
||||
}
|
||||
return experiences;
|
||||
}
|
||||
|
||||
private void setupLevels(int count) {
|
||||
if(count >= 0) {
|
||||
when(level0.getExperienceNeeded()).thenReturn(LVL_0_EXP);
|
||||
}
|
||||
if(count >= 1) {
|
||||
when(level1.getExperienceNeeded()).thenReturn(LVL_1_EXP);
|
||||
}
|
||||
if(count >= 2) {
|
||||
when(level2.getExperienceNeeded()).thenReturn(LVL_2_EXP);
|
||||
}
|
||||
if(count >= 3) {
|
||||
when(level3.getExperienceNeeded()).thenReturn(LVL_3_EXP);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
package dev.sheldan.abstracto.experience.service;
|
||||
|
||||
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
|
||||
import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
|
||||
import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
|
||||
import dev.sheldan.abstracto.experience.service.management.ExperienceLevelManagementService;
|
||||
import org.junit.Assert;
|
||||
@@ -16,7 +15,7 @@ import java.util.Optional;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class ExperienceLevelServiceBeanTest extends ExperienceRelatedTest {
|
||||
public class ExperienceLevelServiceBeanTest {
|
||||
|
||||
@InjectMocks
|
||||
private ExperienceLevelServiceBean testingUnit;
|
||||
|
||||
@@ -7,7 +7,6 @@ import dev.sheldan.abstracto.core.models.database.AServer;
|
||||
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
|
||||
import dev.sheldan.abstracto.core.service.management.RoleManagementService;
|
||||
import dev.sheldan.abstracto.core.utils.CompletableFutureList;
|
||||
import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
|
||||
import dev.sheldan.abstracto.experience.models.RoleCalculationResult;
|
||||
import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
|
||||
import dev.sheldan.abstracto.experience.models.database.AExperienceRole;
|
||||
@@ -32,7 +31,7 @@ import java.util.concurrent.CompletableFuture;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class ExperienceRoleServiceBeanTest extends ExperienceRelatedTest {
|
||||
public class ExperienceRoleServiceBeanTest {
|
||||
|
||||
@InjectMocks
|
||||
private ExperienceRoleServiceBean testingUnit;
|
||||
@@ -127,7 +126,7 @@ public class ExperienceRoleServiceBeanTest extends ExperienceRelatedTest {
|
||||
List<AExperienceRole> roles = getExperienceRoles();
|
||||
AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(6).build()).build();
|
||||
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, userExperience.getLevelOrDefault());
|
||||
Assert.assertEquals(aExperienceRole.getLevel().getLevel().intValue(), 5);
|
||||
Assert.assertEquals(5, aExperienceRole.getLevel().getLevel().intValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -143,7 +142,7 @@ public class ExperienceRoleServiceBeanTest extends ExperienceRelatedTest {
|
||||
List<AExperienceRole> roles = getExperienceRoles();
|
||||
AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(11).build()).build();
|
||||
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, userExperience.getLevelOrDefault());
|
||||
Assert.assertEquals(aExperienceRole.getLevel().getLevel().intValue(), 10);
|
||||
Assert.assertEquals(10, aExperienceRole.getLevel().getLevel().intValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -151,7 +150,7 @@ public class ExperienceRoleServiceBeanTest extends ExperienceRelatedTest {
|
||||
List<AExperienceRole> roles = getExperienceRoles();
|
||||
AUserExperience userExperience = AUserExperience.builder().currentLevel(AExperienceLevel.builder().level(10).build()).build();
|
||||
AExperienceRole aExperienceRole = testingUnit.calculateRole(roles, userExperience.getLevelOrDefault());
|
||||
Assert.assertEquals(aExperienceRole.getLevel().getLevel().intValue(), 10);
|
||||
Assert.assertEquals(10, aExperienceRole.getLevel().getLevel().intValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
@@ -1,17 +0,0 @@
|
||||
package dev.sheldan.abstracto.experience.service;
|
||||
|
||||
import dev.sheldan.abstracto.experience.models.database.LeaderBoardEntryResult;
|
||||
import lombok.Builder;
|
||||
import lombok.Getter;
|
||||
|
||||
@Getter
|
||||
@Builder
|
||||
public class LeaderBoardEntryTestImpl implements LeaderBoardEntryResult {
|
||||
|
||||
private Long id;
|
||||
private Long userInServerId;
|
||||
private Long experience;
|
||||
private Integer level;
|
||||
private Long messageCount;
|
||||
private Integer rank;
|
||||
}
|
||||
@@ -2,7 +2,6 @@ package dev.sheldan.abstracto.experience.service.management;
|
||||
|
||||
import dev.sheldan.abstracto.core.models.database.ARole;
|
||||
import dev.sheldan.abstracto.core.models.database.AServer;
|
||||
import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
|
||||
import dev.sheldan.abstracto.experience.models.database.ADisabledExpRole;
|
||||
import dev.sheldan.abstracto.experience.repository.DisabledExpRoleRepository;
|
||||
import org.junit.Assert;
|
||||
@@ -15,7 +14,7 @@ import org.mockito.junit.MockitoJUnitRunner;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class DisabledExpRoleManagementServiceBeanTest extends ExperienceRelatedTest {
|
||||
public class DisabledExpRoleManagementServiceBeanTest {
|
||||
|
||||
@InjectMocks
|
||||
private DisabledExpRoleManagementServiceBean testUnit;
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
package dev.sheldan.abstracto.experience.service.management;
|
||||
|
||||
import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
|
||||
import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
|
||||
import dev.sheldan.abstracto.experience.repository.ExperienceLevelRepository;
|
||||
import org.junit.Assert;
|
||||
@@ -18,7 +17,7 @@ import static org.mockito.ArgumentMatchers.any;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class ExperienceLevelManagementServiceBeanTest extends ExperienceRelatedTest {
|
||||
public class ExperienceLevelManagementServiceBeanTest {
|
||||
|
||||
@InjectMocks
|
||||
private ExperienceLevelManagementServiceBean testUnit;
|
||||
|
||||
@@ -3,7 +3,6 @@ package dev.sheldan.abstracto.experience.service.management;
|
||||
import dev.sheldan.abstracto.core.models.database.ARole;
|
||||
import dev.sheldan.abstracto.core.models.database.AServer;
|
||||
import dev.sheldan.abstracto.core.test.MockUtils;
|
||||
import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
|
||||
import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
|
||||
import dev.sheldan.abstracto.experience.models.database.AExperienceRole;
|
||||
import dev.sheldan.abstracto.experience.repository.ExperienceRoleRepository;
|
||||
@@ -25,7 +24,7 @@ import static org.mockito.ArgumentMatchers.any;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class ExperienceRoleManagementServiceBeanTest extends ExperienceRelatedTest {
|
||||
public class ExperienceRoleManagementServiceBeanTest {
|
||||
|
||||
@InjectMocks
|
||||
private ExperienceRoleManagementServiceBean testUnit;
|
||||
|
||||
@@ -4,12 +4,10 @@ import dev.sheldan.abstracto.core.models.database.AServer;
|
||||
import dev.sheldan.abstracto.core.models.database.AUser;
|
||||
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
|
||||
import dev.sheldan.abstracto.core.test.MockUtils;
|
||||
import dev.sheldan.abstracto.experience.ExperienceRelatedTest;
|
||||
import dev.sheldan.abstracto.experience.models.database.AExperienceLevel;
|
||||
import dev.sheldan.abstracto.experience.models.database.AUserExperience;
|
||||
import dev.sheldan.abstracto.experience.models.database.LeaderBoardEntryResult;
|
||||
import dev.sheldan.abstracto.experience.repository.UserExperienceRepository;
|
||||
import dev.sheldan.abstracto.experience.service.LeaderBoardEntryTestImpl;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
@@ -26,7 +24,7 @@ import java.util.Optional;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class UserExperienceManagementServiceBeanTest extends ExperienceRelatedTest {
|
||||
public class UserExperienceManagementServiceBeanTest {
|
||||
|
||||
@InjectMocks
|
||||
private UserExperienceManagementServiceBean testUnit;
|
||||
@@ -113,10 +111,8 @@ public class UserExperienceManagementServiceBeanTest extends ExperienceRelatedTe
|
||||
AServer server = MockUtils.getServer();
|
||||
AUserInAServer user = MockUtils.getUserObject(6L, server);
|
||||
AUserExperience experience = AUserExperience.builder().experience(experienceValue).user(user).id(3L).build();
|
||||
LeaderBoardEntryTestImpl leaderBoardEntryTest = LeaderBoardEntryTestImpl
|
||||
.builder()
|
||||
.experience(experienceValue)
|
||||
.build();
|
||||
LeaderBoardEntryResult leaderBoardEntryTest = Mockito.mock(LeaderBoardEntryResult.class);
|
||||
when(leaderBoardEntryTest.getExperience()).thenReturn(experienceValue);
|
||||
when(repository.getRankOfUserInServer(experience.getId(), server.getId())).thenReturn(leaderBoardEntryTest);
|
||||
LeaderBoardEntryResult rankOfUserInServer = testUnit.getRankOfUserInServer(experience);
|
||||
Assert.assertEquals(experienceValue, rankOfUserInServer.getExperience().longValue());
|
||||
|
||||
@@ -1,27 +0,0 @@
|
||||
package dev.sheldan.abstracto.moderation.listener;
|
||||
|
||||
import dev.sheldan.abstracto.core.listener.sync.entity.ServerConfigListener;
|
||||
import dev.sheldan.abstracto.core.models.database.AServer;
|
||||
import dev.sheldan.abstracto.core.service.management.ConfigManagementService;
|
||||
import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
|
||||
import dev.sheldan.abstracto.moderation.config.features.WarningDecayFeature;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.stereotype.Component;
|
||||
|
||||
@Component
|
||||
@Slf4j
|
||||
public class WarnDecayConfigListener implements ServerConfigListener {
|
||||
|
||||
@Autowired
|
||||
private ConfigManagementService configManagementService;
|
||||
|
||||
@Autowired
|
||||
private DefaultConfigManagementService defaultConfigManagementService;
|
||||
|
||||
@Override
|
||||
public void updateServerConfig(AServer server) {
|
||||
log.info("Updating decay day configuration for server {}.", server.getId());
|
||||
configManagementService.loadOrCreateIfNotExists(server.getId(), WarningDecayFeature.DECAY_DAYS_KEY, defaultConfigManagementService.getDefaultConfig(WarningDecayFeature.DECAY_DAYS_KEY).getLongValue());
|
||||
}
|
||||
}
|
||||
@@ -5,6 +5,7 @@ import dev.sheldan.abstracto.core.models.ServerSpecificId;
|
||||
import dev.sheldan.abstracto.core.models.database.AServer;
|
||||
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
|
||||
import dev.sheldan.abstracto.core.service.*;
|
||||
import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
|
||||
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
|
||||
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
|
||||
import dev.sheldan.abstracto.core.utils.FutureUtils;
|
||||
@@ -70,6 +71,9 @@ public class WarnServiceBean implements WarnService {
|
||||
@Autowired
|
||||
private ServerManagementService serverManagementService;
|
||||
|
||||
@Autowired
|
||||
private DefaultConfigManagementService defaultConfigManagementService;
|
||||
|
||||
@Autowired
|
||||
private FeatureModeService featureModeService;
|
||||
|
||||
@@ -124,8 +128,9 @@ public class WarnServiceBean implements WarnService {
|
||||
|
||||
@Override
|
||||
@Transactional
|
||||
public CompletableFuture<Void> decayWarningsForServer(AServer server) {
|
||||
Long days = configService.getLongValue(WarningDecayFeature.DECAY_DAYS_KEY, server.getId());
|
||||
public CompletableFuture<Void> decayWarningsForServer(AServer server) {
|
||||
Long defaultDays = defaultConfigManagementService.getDefaultConfig(WarningDecayFeature.DECAY_DAYS_KEY).getLongValue();
|
||||
Long days = configService.getLongValue(WarningDecayFeature.DECAY_DAYS_KEY, server.getId(), defaultDays);
|
||||
Instant cutOffDay = Instant.now().minus(days, ChronoUnit.DAYS);
|
||||
log.info("Decaying warnings on server {} which are older than {}.", server.getId(), cutOffDay);
|
||||
List<Warning> warningsToDecay = warnManagementService.getActiveWarningsInServerOlderThan(server, cutOffDay);
|
||||
|
||||
@@ -3,7 +3,9 @@ package dev.sheldan.abstracto.moderation.service;
|
||||
import dev.sheldan.abstracto.core.models.ServerSpecificId;
|
||||
import dev.sheldan.abstracto.core.models.database.AServer;
|
||||
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
|
||||
import dev.sheldan.abstracto.core.models.property.SystemConfigProperty;
|
||||
import dev.sheldan.abstracto.core.service.*;
|
||||
import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
|
||||
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
|
||||
import dev.sheldan.abstracto.core.test.command.CommandTestUtilities;
|
||||
import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
|
||||
@@ -24,10 +26,7 @@ import net.dv8tion.jda.api.entities.User;
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.ArgumentCaptor;
|
||||
import org.mockito.Captor;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.*;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import java.time.Instant;
|
||||
@@ -122,6 +121,9 @@ public class WarnServiceBeanTest {
|
||||
@Mock
|
||||
private FeatureModeService featureModeService;
|
||||
|
||||
@Mock
|
||||
private DefaultConfigManagementService defaultConfigManagementService;
|
||||
|
||||
private static final String NOTIFICATION_TEXT = "text";
|
||||
private static final String GUILD_NAME = "guild";
|
||||
private static final Long SERVER_ID = 4L;
|
||||
@@ -129,7 +131,7 @@ public class WarnServiceBeanTest {
|
||||
@Test
|
||||
public void testDecayWarning() {
|
||||
Instant date = Instant.now();
|
||||
when(firstWarning.getWarnId()).thenReturn(new ServerSpecificId(3L, 4L));
|
||||
when(firstWarning.getWarnId()).thenReturn(new ServerSpecificId(SERVER_ID, 4L));
|
||||
testUnit.decayWarning(firstWarning, date);
|
||||
verify(firstWarning, times(1)).setDecayed(true);
|
||||
verify(firstWarning, times(1)).setDecayDate(date);
|
||||
@@ -233,7 +235,11 @@ public class WarnServiceBeanTest {
|
||||
|
||||
private void setupWarnDecay() {
|
||||
setupWarnings();
|
||||
when(configService.getLongValue(WarningDecayFeature.DECAY_DAYS_KEY, server.getId())).thenReturn(5L);
|
||||
SystemConfigProperty defaultDecayDays = Mockito.mock(SystemConfigProperty.class);
|
||||
Long defaultDayCount = 4L;
|
||||
when(defaultDecayDays.getLongValue()).thenReturn(defaultDayCount);
|
||||
when(defaultConfigManagementService.getDefaultConfig(WarningDecayFeature.DECAY_DAYS_KEY)).thenReturn(defaultDecayDays);
|
||||
when(configService.getLongValue(WarningDecayFeature.DECAY_DAYS_KEY, SERVER_ID, defaultDayCount)).thenReturn(5L);
|
||||
List<Warning> warnings = Arrays.asList(firstWarning, secondWarning);
|
||||
when(memberService.getMemberInServerAsync(warningUser)).thenReturn(CompletableFuture.completedFuture(warningMember));
|
||||
when(memberService.getMemberInServerAsync(firstWarnedUser)).thenReturn(CompletableFuture.completedFuture(warnedMember));
|
||||
|
||||
@@ -1,36 +0,0 @@
|
||||
package dev.sheldan.abstracto.modmail.listener;
|
||||
|
||||
import dev.sheldan.abstracto.core.listener.sync.entity.ServerConfigListener;
|
||||
import dev.sheldan.abstracto.core.models.database.AServer;
|
||||
import dev.sheldan.abstracto.core.service.management.ConfigManagementService;
|
||||
import dev.sheldan.abstracto.modmail.service.ModMailThreadServiceBean;
|
||||
import dev.sheldan.abstracto.core.templating.service.TemplateService;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.stereotype.Component;
|
||||
|
||||
import static dev.sheldan.abstracto.modmail.service.ModMailThreadServiceBean.MODMAIL_CLOSING_MESSAGE_TEXT;
|
||||
|
||||
/**
|
||||
* This listener is used to used to set the initial values of some server specific values, so we don't need to fall
|
||||
* back to the default values. The values might not be functional, for example mod mail category id, but their existence
|
||||
* makes things easier
|
||||
*/
|
||||
@Component
|
||||
@Slf4j
|
||||
public class ModMailConfigListener implements ServerConfigListener {
|
||||
|
||||
|
||||
@Autowired
|
||||
private ConfigManagementService configService;
|
||||
|
||||
@Autowired
|
||||
private TemplateService templateService;
|
||||
|
||||
@Override
|
||||
public void updateServerConfig(AServer server) {
|
||||
log.info("Updating modmail related configuration for server {}.", server.getId());
|
||||
configService.loadOrCreateIfNotExists(server.getId(), ModMailThreadServiceBean.MODMAIL_CATEGORY, 0L);
|
||||
configService.loadOrCreateIfNotExists(server.getId(), MODMAIL_CLOSING_MESSAGE_TEXT, templateService.renderSimpleTemplate("modmail_closing_user_message_description"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
package dev.sheldan.abstracto.core.commands.config;
|
||||
|
||||
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.config.features.CoreFeatures;
|
||||
import dev.sheldan.abstracto.core.command.execution.CommandContext;
|
||||
import dev.sheldan.abstracto.core.command.execution.CommandResult;
|
||||
import dev.sheldan.abstracto.core.command.service.management.FeatureManagementService;
|
||||
import dev.sheldan.abstracto.core.config.FeatureEnum;
|
||||
import dev.sheldan.abstracto.core.exception.ConfigurationKeyNotFoundException;
|
||||
import dev.sheldan.abstracto.core.service.ConfigService;
|
||||
import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.stereotype.Component;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
|
||||
@Component
|
||||
public class ResetConfig extends AbstractConditionableCommand {
|
||||
|
||||
@Autowired
|
||||
private ConfigService configService;
|
||||
|
||||
@Autowired
|
||||
private DefaultConfigManagementService defaultConfigManagementService;
|
||||
|
||||
@Autowired
|
||||
private FeatureManagementService featureManagementService;
|
||||
|
||||
@Override
|
||||
public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
|
||||
Long serverId = commandContext.getGuild().getIdLong();
|
||||
if(!commandContext.getParameters().getParameters().isEmpty()) {
|
||||
String name = (String) commandContext.getParameters().getParameters().get(0);
|
||||
if(featureManagementService.featureExists(name)) {
|
||||
configService.resetConfigForFeature(name, serverId);
|
||||
} else if(defaultConfigManagementService.configKeyExists(name)) {
|
||||
configService.resetConfigForKey(name, serverId);
|
||||
} else {
|
||||
throw new ConfigurationKeyNotFoundException(name);
|
||||
}
|
||||
} else {
|
||||
configService.resetConfigForServer(serverId);
|
||||
}
|
||||
return CompletableFuture.completedFuture(CommandResult.fromSuccess());
|
||||
}
|
||||
|
||||
@Override
|
||||
public CommandConfiguration getConfiguration() {
|
||||
Parameter keyToChange = Parameter.builder().name("key").type(String.class).optional(true).templated(true).build();
|
||||
List<Parameter> parameters = Arrays.asList(keyToChange);
|
||||
HelpInfo helpInfo = HelpInfo.builder().templated(true).hasExample(true).build();
|
||||
return CommandConfiguration.builder()
|
||||
.name("resetConfig")
|
||||
.module(ConfigModuleInterface.CONFIG)
|
||||
.parameters(parameters)
|
||||
.templated(true)
|
||||
.async(true)
|
||||
.supportsEmbedException(true)
|
||||
.help(helpInfo)
|
||||
.causesReaction(true)
|
||||
.build();
|
||||
}
|
||||
|
||||
@Override
|
||||
public FeatureEnum getFeature() {
|
||||
return CoreFeatures.CORE_FEATURE;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -21,7 +21,6 @@ public class SetConfig extends AbstractConditionableCommand {
|
||||
@Autowired
|
||||
private ConfigService configService;
|
||||
|
||||
|
||||
@Override
|
||||
public CommandResult execute(CommandContext commandContext) {
|
||||
String key = (String) commandContext.getParameters().getParameters().get(0);
|
||||
|
||||
@@ -6,10 +6,12 @@ import dev.sheldan.abstracto.core.models.property.PostTargetProperty;
|
||||
import dev.sheldan.abstracto.core.models.property.SystemConfigProperty;
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
import org.apache.commons.lang3.tuple.Pair;
|
||||
import org.springframework.boot.context.properties.ConfigurationProperties;
|
||||
import org.springframework.context.annotation.Configuration;
|
||||
|
||||
import java.util.Map;
|
||||
import javax.annotation.PostConstruct;
|
||||
import java.util.*;
|
||||
|
||||
@Getter
|
||||
@Setter
|
||||
@@ -20,4 +22,26 @@ public class DefaultConfigProperties {
|
||||
private Map<String, FeatureFlagProperty> featureFlags;
|
||||
private Map<String, PostTargetProperty> postTargets;
|
||||
private Map<String, FeatureModeProperty> featureModes;
|
||||
|
||||
/**
|
||||
* This is required to make the keys all lower case, so we can search for them faster, and also make it possible
|
||||
* for users to not require exact names
|
||||
*/
|
||||
@PostConstruct
|
||||
public void postConstruct() {
|
||||
makeKeysLowerCase(systemConfigs);
|
||||
makeKeysLowerCase(featureFlags);
|
||||
makeKeysLowerCase(postTargets);
|
||||
makeKeysLowerCase(featureModes);
|
||||
}
|
||||
|
||||
private <T> void makeKeysLowerCase(Map<String, T> map) {
|
||||
Set<String> keys = new HashSet<>(map.keySet());
|
||||
List<Pair<String, T>> pairs = new ArrayList<>();
|
||||
keys.forEach(s ->
|
||||
pairs.add(Pair.of(s.toLowerCase(), map.get(s)))
|
||||
);
|
||||
keys.forEach(map::remove);
|
||||
pairs.forEach(stringTPair -> map.put(stringTPair.getKey(), stringTPair.getValue()));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,27 +0,0 @@
|
||||
package dev.sheldan.abstracto.core.listener.sync.entity;
|
||||
|
||||
import dev.sheldan.abstracto.core.command.service.CommandManager;
|
||||
import dev.sheldan.abstracto.core.models.database.AServer;
|
||||
import dev.sheldan.abstracto.core.service.management.ConfigManagementService;
|
||||
import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
|
||||
import lombok.extern.slf4j.Slf4j;
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.stereotype.Component;
|
||||
|
||||
@Component
|
||||
@Slf4j
|
||||
public class CoreServiceConfigListener implements ServerConfigListener {
|
||||
|
||||
@Autowired
|
||||
private ConfigManagementService configManagementService;
|
||||
|
||||
@Autowired
|
||||
private DefaultConfigManagementService defaultConfigManagementService;
|
||||
|
||||
@Override
|
||||
public void updateServerConfig(AServer server) {
|
||||
log.info("Creating prefix config for server {}.", server.getId());
|
||||
String defaultPrefix = defaultConfigManagementService.getDefaultConfig(CommandManager.PREFIX).getStringValue();
|
||||
configManagementService.loadOrCreateIfNotExists(server.getId(), CommandManager.PREFIX, defaultPrefix);
|
||||
}
|
||||
}
|
||||
@@ -9,9 +9,10 @@ import org.springframework.stereotype.Repository;
|
||||
@Repository
|
||||
public interface ConfigRepository extends JpaRepository<AConfig, Long> {
|
||||
|
||||
AConfig findAConfigByServerIdAndName(Long serverId, String name);
|
||||
AConfig findAConfigByServerIdAndNameIgnoreCase(Long serverId, String name);
|
||||
void deleteAConfigByServerId(Long serverId);
|
||||
|
||||
boolean existsAConfigByServerIdAndName(Long serverId, String name);
|
||||
boolean existsAConfigByServerIdAndNameIgnoreCase(Long serverId, String name);
|
||||
|
||||
boolean existsAConfigByServerAndName(AServer server, String name);
|
||||
boolean existsAConfigByServerAndNameIgnoreCase(AServer server, String name);
|
||||
}
|
||||
|
||||
@@ -8,5 +8,5 @@ import org.springframework.stereotype.Repository;
|
||||
@Repository
|
||||
public interface FeatureRepository extends JpaRepository<AFeature, Long> {
|
||||
|
||||
AFeature findByKey(String key);
|
||||
AFeature findByKeyIgnoreCase(String key);
|
||||
}
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
package dev.sheldan.abstracto.core.service;
|
||||
|
||||
import dev.sheldan.abstracto.core.config.FeatureConfig;
|
||||
import dev.sheldan.abstracto.core.exception.ConfigurationKeyNotFoundException;
|
||||
import dev.sheldan.abstracto.core.models.database.AConfig;
|
||||
import dev.sheldan.abstracto.core.models.property.SystemConfigProperty;
|
||||
@@ -17,6 +18,9 @@ public class ConfigServiceBean implements ConfigService {
|
||||
@Autowired
|
||||
private DefaultConfigManagementService defaultConfigManagementService;
|
||||
|
||||
@Autowired
|
||||
private FeatureConfigService featureConfigService;
|
||||
|
||||
@Override
|
||||
public Double getDoubleValue(String name, Long serverId) {
|
||||
return getDoubleValue(name, serverId, 0D);
|
||||
@@ -93,7 +97,7 @@ public class ConfigServiceBean implements ConfigService {
|
||||
public AConfig setOrCreateConfigValue(String name, Long serverId, String value) {
|
||||
if(defaultConfigManagementService.configKeyExists(name)) {
|
||||
AConfig fakeConfigValue = getFakeConfigForValue(name, value);
|
||||
return setOrCreateConfigValue(serverId, name, fakeConfigValue);
|
||||
return setOrCreateConfigValue(serverId, fakeConfigValue.getName(), fakeConfigValue);
|
||||
} else {
|
||||
throw new ConfigurationKeyNotFoundException(name);
|
||||
}
|
||||
@@ -143,8 +147,8 @@ public class ConfigServiceBean implements ConfigService {
|
||||
@Override
|
||||
public AConfig getFakeConfigForValue(String name, String value) {
|
||||
if(defaultConfigManagementService.configKeyExists(name)) {
|
||||
AConfig newConfig = AConfig.builder().name(value).build();
|
||||
SystemConfigProperty defaultConfig = defaultConfigManagementService.getDefaultConfig(name);
|
||||
AConfig newConfig = AConfig.builder().name(defaultConfig.getName()).build();
|
||||
if(defaultConfig.getDoubleValue() != null) {
|
||||
newConfig.setDoubleValue(Double.parseDouble(value));
|
||||
} else if(defaultConfig.getLongValue() != null) {
|
||||
@@ -157,4 +161,24 @@ public class ConfigServiceBean implements ConfigService {
|
||||
throw new ConfigurationKeyNotFoundException(name);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void resetConfigForKey(String configKey, Long serverId) {
|
||||
configManagementService.deleteConfig(serverId, configKey);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void resetConfigForFeature(String featureKey, Long serverId) {
|
||||
FeatureConfig featureConfig = featureConfigService.getFeatureDisplayForFeature(featureKey);
|
||||
featureConfig.getRequiredSystemConfigKeys().forEach(s -> {
|
||||
if(configManagementService.configExists(serverId, s)) {
|
||||
resetConfigForKey(s, serverId);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@Override
|
||||
public void resetConfigForServer(Long serverId) {
|
||||
configManagementService.deleteConfigForServer(serverId);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -121,17 +121,17 @@ public class ConfigManagementServiceBean implements ConfigManagementService {
|
||||
|
||||
@Override
|
||||
public AConfig loadConfig(Long serverId, String name) {
|
||||
return configRepository.findAConfigByServerIdAndName(serverId, name);
|
||||
return configRepository.findAConfigByServerIdAndNameIgnoreCase(serverId, name);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean configExists(Long serverId, String name) {
|
||||
return configRepository.existsAConfigByServerIdAndName(serverId, name);
|
||||
return configRepository.existsAConfigByServerIdAndNameIgnoreCase(serverId, name);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean configExists(AServer server, String name) {
|
||||
return configRepository.existsAConfigByServerAndName(server, name);
|
||||
return configRepository.existsAConfigByServerAndNameIgnoreCase(server, name);
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -158,4 +158,15 @@ public class ConfigManagementServiceBean implements ConfigManagementService {
|
||||
return config;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void deleteConfig(Long serverId, String name) {
|
||||
AConfig config = loadConfig(serverId, name);
|
||||
configRepository.delete(config);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void deleteConfigForServer(Long serverId) {
|
||||
configRepository.deleteAConfigByServerId(serverId);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -15,11 +15,11 @@ public class DefaultConfigManagementServiceBean implements DefaultConfigManageme
|
||||
|
||||
@Override
|
||||
public SystemConfigProperty getDefaultConfig(String key) {
|
||||
return defaultConfigProperties.getSystemConfigs().get(key);
|
||||
return defaultConfigProperties.getSystemConfigs().get(key.toLowerCase());
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean configKeyExists(String key) {
|
||||
return defaultConfigProperties.getSystemConfigs().containsKey(key);
|
||||
return defaultConfigProperties.getSystemConfigs().containsKey(key.toLowerCase());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -32,6 +32,6 @@ public class FeatureManagementServiceBean implements FeatureManagementService {
|
||||
|
||||
@Override
|
||||
public AFeature getFeature(String key) {
|
||||
return featureRepository.findByKey(key);
|
||||
return featureRepository.findByKeyIgnoreCase(key);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -97,6 +97,12 @@
|
||||
<column name="feature_id" valueComputed="${coreFeature}"/>
|
||||
<column name="created" valueComputed="${today}"/>
|
||||
</insert>
|
||||
<insert tableName="command">
|
||||
<column name="name" value="resetConfig"/>
|
||||
<column name="module_id" valueComputed="${configModule}"/>
|
||||
<column name="feature_id" valueComputed="${coreFeature}"/>
|
||||
<column name="created" valueComputed="${today}"/>
|
||||
</insert>
|
||||
<insert tableName="command">
|
||||
<column name="name" value="setPrefix"/>
|
||||
<column name="module_id" valueComputed="${configModule}"/>
|
||||
|
||||
@@ -17,5 +17,7 @@ public interface ConfigService {
|
||||
void setStringValue(String name, Long serverId, String value);
|
||||
boolean configurationIsValid(String name, String value);
|
||||
AConfig getFakeConfigForValue(String name, String value);
|
||||
|
||||
void resetConfigForKey(String configKey, Long serverId);
|
||||
void resetConfigForFeature(String featureKey, Long serverId);
|
||||
void resetConfigForServer(Long serverId);
|
||||
}
|
||||
|
||||
@@ -19,4 +19,6 @@ public interface ConfigManagementService {
|
||||
AConfig setDoubleValue(Long serverId, String name, Double value);
|
||||
AConfig setLongValue(Long serverId, String name, Long value);
|
||||
AConfig setStringValue(Long serverId, String name, String value);
|
||||
void deleteConfig(Long serverId, String name);
|
||||
void deleteConfigForServer(Long serverId);
|
||||
}
|
||||
|
||||
@@ -18,6 +18,9 @@ Changing the system configuration::
|
||||
* Usage `setConfig <key> <value>`
|
||||
* Description: Changes the value of this configuration identified by `key` to `value`. Some of these configurations have separate commands, but this works in general.
|
||||
* Example: `setConfig expMin 15` to set the minimum experience to 15
|
||||
Resetting the configuration to default values::
|
||||
* Usage `resetConfig [key/feature]`
|
||||
* Description: Resets the configuration of the given `key` or for the complete feature identified by `feature`. If this is not provided, it will reset the entire server to the default configuration.
|
||||
Changing emotes Abstracto uses::
|
||||
* Usage: `setEmote <key> <emote>`
|
||||
* Description: Sets the emote identified by `key` used by Abstracto on this server to `emote`.
|
||||
|
||||
Reference in New Issue
Block a user