From c10296251c5fc12e871508e3441d2438de2be043 Mon Sep 17 00:00:00 2001 From: Sheldan <5037282+Sheldan@users.noreply.github.com> Date: Sat, 27 Nov 2021 22:08:12 +0100 Subject: [PATCH] [AB-327] adding a third state to the result of a system condition: Ignored, this means that the condition was not evaluated, and is neither true nor false, this is for example used when the feature the condition is about is disabled adding server ID to has level condition parameters --- .../antiraid/service/MassPingServiceBean.java | 6 +++- ...signableRoleMinimumLevelConditionImpl.java | 6 +++- .../service/condition/HasLevelCondition.java | 23 ++++++++++++--- .../core/service/ConditionServiceBean.java | 28 +++++++++---------- .../core/service/ConditionService.java | 2 +- .../core/service/SystemCondition.java | 14 +++++++++- 6 files changed, 56 insertions(+), 23 deletions(-) diff --git a/abstracto-application/abstracto-modules/anti-raid/anti-raid-impl/src/main/java/dev/sheldan/abstracto/antiraid/service/MassPingServiceBean.java b/abstracto-application/abstracto-modules/anti-raid/anti-raid-impl/src/main/java/dev/sheldan/abstracto/antiraid/service/MassPingServiceBean.java index b95024284..4fdcafd02 100644 --- a/abstracto-application/abstracto-modules/anti-raid/anti-raid-impl/src/main/java/dev/sheldan/abstracto/antiraid/service/MassPingServiceBean.java +++ b/abstracto-application/abstracto-modules/anti-raid/anti-raid-impl/src/main/java/dev/sheldan/abstracto/antiraid/service/MassPingServiceBean.java @@ -8,6 +8,7 @@ import dev.sheldan.abstracto.core.models.template.display.MemberDisplay; import dev.sheldan.abstracto.core.service.ConditionService; import dev.sheldan.abstracto.core.service.ConfigService; import dev.sheldan.abstracto.core.service.PostTargetService; +import dev.sheldan.abstracto.core.service.SystemCondition; import dev.sheldan.abstracto.core.service.management.UserInServerManagementService; import dev.sheldan.abstracto.core.templating.model.MessageToSend; import dev.sheldan.abstracto.core.templating.service.TemplateService; @@ -34,6 +35,7 @@ public class MassPingServiceBean implements MassPingService { private static final String LEVEL_CONDITION_NAME = "HAS_LEVEL"; private static final String LEVEL_CONDITION_USER_ID_PARAMETER = "userId"; private static final String LEVEL_CONDITION_LEVEL_PARAMETER = "level"; + private static final String LEVEL_CONDITION_SERVER_PARAMETER = "serverId"; @Autowired private ConfigService configService; @@ -85,12 +87,14 @@ public class MassPingServiceBean implements MassPingService { AUserInAServer userInAServer = userInServerManagementService.loadOrCreateUser(message.getMember()); parameters.put(LEVEL_CONDITION_USER_ID_PARAMETER, userInAServer.getUserInServerId()); parameters.put(LEVEL_CONDITION_LEVEL_PARAMETER, level); + parameters.put(LEVEL_CONDITION_SERVER_PARAMETER, message.getGuild().getIdLong()); ConditionContextInstance contextInstance = ConditionContextInstance .builder() .conditionName(LEVEL_CONDITION_NAME) .parameters(parameters) .build(); - return conditionService.checkConditions(contextInstance); + SystemCondition.Result result = conditionService.checkConditions(contextInstance); + return SystemCondition.Result.consideredSuccessful(result); } @Transactional diff --git a/abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/condition/AssignableRoleMinimumLevelConditionImpl.java b/abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/condition/AssignableRoleMinimumLevelConditionImpl.java index bbca80e2f..800e603e6 100644 --- a/abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/condition/AssignableRoleMinimumLevelConditionImpl.java +++ b/abstracto-application/abstracto-modules/assignable-roles/assignable-roles-impl/src/main/java/dev/sheldan/abstracto/assignableroles/condition/AssignableRoleMinimumLevelConditionImpl.java @@ -11,6 +11,7 @@ import dev.sheldan.abstracto.core.models.ConditionContextInstance; import dev.sheldan.abstracto.core.models.database.AUserInAServer; import dev.sheldan.abstracto.core.models.template.display.RoleDisplay; import dev.sheldan.abstracto.core.service.ConditionService; +import dev.sheldan.abstracto.core.service.SystemCondition; import net.dv8tion.jda.api.entities.Role; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @@ -24,6 +25,7 @@ public class AssignableRoleMinimumLevelConditionImpl implements AssignableRoleCo private final String conditionName = "HAS_LEVEL"; private final String userIdParameter = "userId"; private final String levelParameter = "level"; + private final String serverParameter = "serverId"; @Autowired private ConditionService conditionService; @@ -34,13 +36,15 @@ public class AssignableRoleMinimumLevelConditionImpl implements AssignableRoleCo Map parameters = new HashMap<>(); parameters.put(userIdParameter, aUserInAServer.getUserInServerId()); parameters.put(levelParameter, level); + parameters.put(serverParameter, aUserInAServer.getServerReference().getId()); ConditionContextInstance contextInstance = ConditionContextInstance .builder() .conditionName(conditionName) .parameters(parameters) .build(); - return conditionService.checkConditions(contextInstance); + SystemCondition.Result result = conditionService.checkConditions(contextInstance); + return SystemCondition.Result.consideredSuccessful(result); } @Override diff --git a/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/condition/HasLevelCondition.java b/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/condition/HasLevelCondition.java index 500272be4..8d2c36a70 100644 --- a/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/condition/HasLevelCondition.java +++ b/abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/condition/HasLevelCondition.java @@ -4,8 +4,10 @@ import dev.sheldan.abstracto.core.models.ConditionContext; import dev.sheldan.abstracto.core.models.ConditionContextInstance; import dev.sheldan.abstracto.core.models.ConditionContextVariable; import dev.sheldan.abstracto.core.models.database.AUserInAServer; +import dev.sheldan.abstracto.core.service.FeatureFlagService; import dev.sheldan.abstracto.core.service.SystemCondition; import dev.sheldan.abstracto.core.service.management.UserInServerManagementService; +import dev.sheldan.abstracto.experience.config.ExperienceFeatureDefinition; import dev.sheldan.abstracto.experience.model.database.AUserExperience; import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService; import lombok.extern.slf4j.Slf4j; @@ -26,6 +28,7 @@ public class HasLevelCondition implements SystemCondition { public static final String USER_IN_SERVER_ID_VARIABLE_KEY = "userId"; public static final String LEVEL_VARIABLE = "level"; + public static final String SERVER_VARIABLE = "serverId"; public static final String HAS_LEVEL_CONDITION_KEY = "HAS_LEVEL"; @Autowired @@ -34,11 +37,18 @@ public class HasLevelCondition implements SystemCondition { @Autowired private UserInServerManagementService userInServerManagementService; + @Autowired + private FeatureFlagService featureFlagService; + @Override - public boolean checkCondition(ConditionContextInstance conditionContext) { + public Result checkCondition(ConditionContextInstance conditionContext) { Map parameters = conditionContext.getParameters(); Long userInServerId = (Long) parameters.get(USER_IN_SERVER_ID_VARIABLE_KEY); + Long serverId = (Long) parameters.get(SERVER_VARIABLE); Integer level = (Integer) parameters.get(LEVEL_VARIABLE); + if(!featureFlagService.getFeatureFlagValue(ExperienceFeatureDefinition.EXPERIENCE, serverId)) { + return Result.IGNORED; + } Optional userInServerOptional = userInServerManagementService.loadUserOptional(userInServerId); if(userInServerOptional.isPresent()) { AUserInAServer userInServer = userInServerOptional.get(); @@ -47,11 +57,11 @@ public class HasLevelCondition implements SystemCondition { AUserExperience user = userExperienceManagementService.findUserInServer(userInServer); boolean conditionResult = user.getCurrentLevel() != null && user.getCurrentLevel().getLevel() >= level; log.info("Condition evaluated to {}", conditionResult); - return conditionResult; + return Result.fromBoolean(conditionResult); } log.info("No user in server object was found. Evaluating has level to false."); - return false; + return Result.FAILED; } @Override @@ -71,9 +81,14 @@ public class HasLevelCondition implements SystemCondition { .name(LEVEL_VARIABLE) .type(Integer.class) .build(); + ConditionContextVariable serverVariable = ConditionContextVariable + .builder() + .name(SERVER_VARIABLE) + .type(Long.class) + .build(); return ConditionContext .builder() - .requiredVariables(Arrays.asList(userIdVariable, levelVariable)) + .requiredVariables(Arrays.asList(userIdVariable, levelVariable, serverVariable)) .build(); } } diff --git a/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/ConditionServiceBean.java b/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/ConditionServiceBean.java index 9c9ac4f09..534c7671e 100644 --- a/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/ConditionServiceBean.java +++ b/abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/ConditionServiceBean.java @@ -9,7 +9,6 @@ import org.springframework.stereotype.Component; import java.util.List; import java.util.Map; -import java.util.Optional; @Component @Slf4j @@ -19,32 +18,31 @@ public class ConditionServiceBean implements ConditionService { private List conditionList; @Override - public boolean checkConditions(ConditionContextInstance context) { - if(conditionList == null || conditionList.isEmpty()) { - return true; + public SystemCondition.Result checkConditions(ConditionContextInstance context) { + if (conditionList == null || conditionList.isEmpty()) { + return SystemCondition.Result.SUCCESSFUL; } - Optional matchingCondition = conditionList + log.debug("Checking condition {}.", context.getConditionName()); + return conditionList .stream() .filter(systemCondition -> systemCondition.getConditionName().equalsIgnoreCase(context.getConditionName())) - .findAny(); - log.debug("Checking condition {}.", context.getConditionName()); - return matchingCondition.map(systemCondition -> { - verifyConditionContext(context, systemCondition); - boolean result = systemCondition.checkCondition(context); - log.debug("Condition resulted in {}.", result); - return result; - }).orElse(true); + .findAny().map(systemCondition -> { + verifyConditionContext(context, systemCondition); + SystemCondition.Result result = systemCondition.checkCondition(context); + log.debug("Condition resulted in {}.", result); + return result; + }).orElse(SystemCondition.Result.SUCCESSFUL); } private void verifyConditionContext(ConditionContextInstance contextInstance, SystemCondition condition) { for (ConditionContextVariable conditionContextVariable : condition.getExpectedContext().getRequiredVariables()) { Map providedParameters = contextInstance.getParameters(); - if(!providedParameters.containsKey(conditionContextVariable.getName())) { + if (!providedParameters.containsKey(conditionContextVariable.getName())) { throw new InvalidConditionParametersException(String.format("Variable %s was not present", conditionContextVariable.getName())); } Class expectedType = conditionContextVariable.getType(); Object providedParameter = providedParameters.get(conditionContextVariable.getName()); - if(!expectedType.isInstance(providedParameter)) { + if (!expectedType.isInstance(providedParameter)) { throw new InvalidConditionParametersException(String.format("Variable %s was of type %s instead of %s.", conditionContextVariable.getName(), providedParameter.getClass(), expectedType)); } diff --git a/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/ConditionService.java b/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/ConditionService.java index 5b21862d3..3791cacf6 100644 --- a/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/ConditionService.java +++ b/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/ConditionService.java @@ -3,5 +3,5 @@ package dev.sheldan.abstracto.core.service; import dev.sheldan.abstracto.core.models.ConditionContextInstance; public interface ConditionService { - boolean checkConditions(ConditionContextInstance context); + SystemCondition.Result checkConditions(ConditionContextInstance context); } diff --git a/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/SystemCondition.java b/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/SystemCondition.java index 41d340638..07f89af1e 100644 --- a/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/SystemCondition.java +++ b/abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/SystemCondition.java @@ -4,7 +4,19 @@ import dev.sheldan.abstracto.core.models.ConditionContext; import dev.sheldan.abstracto.core.models.ConditionContextInstance; public interface SystemCondition { - boolean checkCondition(ConditionContextInstance conditionContext); + Result checkCondition(ConditionContextInstance conditionContext); String getConditionName(); ConditionContext getExpectedContext(); + + enum Result { + SUCCESSFUL, FAILED, IGNORED; + + public static Result fromBoolean(boolean value) { + return value ? SUCCESSFUL : FAILED; + } + + public static boolean consideredSuccessful(Result result) { + return result == Result.SUCCESSFUL || result == Result.IGNORED; + } + } }