[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

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

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<String, Object> 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

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<String, Object> 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<AUserInAServer> 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();
     }
 }

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<SystemCondition> conditionList;
 
     @Override
-    public boolean checkConditions(ConditionContextInstance context) {
+    public SystemCondition.Result checkConditions(ConditionContextInstance context) {
-        if(conditionList == null ||  conditionList.isEmpty()) {
+        if (conditionList == null || conditionList.isEmpty()) {
-            return true;
+            return SystemCondition.Result.SUCCESSFUL;
         }
-        Optional<SystemCondition> matchingCondition = conditionList
+        log.debug("Checking condition {}.", context.getConditionName());
+        return conditionList
                 .stream()
                 .filter(systemCondition -> systemCondition.getConditionName().equalsIgnoreCase(context.getConditionName()))
-                .findAny();
+                .findAny().map(systemCondition -> {
-        log.debug("Checking condition {}.", context.getConditionName());
+                    verifyConditionContext(context, systemCondition);
-        return matchingCondition.map(systemCondition -> {
+                    SystemCondition.Result result = systemCondition.checkCondition(context);
-            verifyConditionContext(context, systemCondition);
+                    log.debug("Condition resulted in {}.", result);
-            boolean result = systemCondition.checkCondition(context);
+                    return result;
-            log.debug("Condition resulted in {}.", result);
+                }).orElse(SystemCondition.Result.SUCCESSFUL);
-            return result;
-        }).orElse(true);
     }
 
     private void verifyConditionContext(ConditionContextInstance contextInstance, SystemCondition condition) {
         for (ConditionContextVariable conditionContextVariable : condition.getExpectedContext().getRequiredVariables()) {
             Map<String, Object> 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));
             }

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);
 }

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;
+        }
+    }
 }