From 183d2ca4f08443c9c63c70459f448f386be7c496 Mon Sep 17 00:00:00 2001 From: Zofia Wrona Date: Wed, 8 May 2024 05:33:46 +0200 Subject: [PATCH] [JRBA] Fix rule set modification for duplicated rule types --- pom.xml | 2 +- .../jrba/utils/rules/RuleSetConstructor.java | 52 +++++++++++-------- 2 files changed, 32 insertions(+), 22 deletions(-) diff --git a/pom.xml b/pom.xml index c786080..5a401d6 100644 --- a/pom.xml +++ b/pom.xml @@ -7,7 +7,7 @@ io.github.extended-green-cloud jrba - 1.3.3 + 1.3.4 jar diff --git a/src/main/java/org/jrba/utils/rules/RuleSetConstructor.java b/src/main/java/org/jrba/utils/rules/RuleSetConstructor.java index 7c0ccad..fdb3ccc 100644 --- a/src/main/java/org/jrba/utils/rules/RuleSetConstructor.java +++ b/src/main/java/org/jrba/utils/rules/RuleSetConstructor.java @@ -1,6 +1,7 @@ package org.jrba.utils.rules; import static java.util.Objects.nonNull; +import static org.jrba.rulesengine.rest.RuleSetRestApi.getAvailableRuleSets; import static org.jrba.rulesengine.types.ruletype.AgentRuleTypeEnum.CFP; import static org.jrba.rulesengine.types.ruletype.AgentRuleTypeEnum.COMBINED; import static org.jrba.rulesengine.types.ruletype.AgentRuleTypeEnum.LISTENER; @@ -11,22 +12,22 @@ import static org.jrba.rulesengine.types.ruletype.AgentRuleTypeEnum.SCHEDULED; import static org.jrba.rulesengine.types.ruletype.AgentRuleTypeEnum.SEARCH; import static org.jrba.rulesengine.types.ruletype.AgentRuleTypeEnum.SUBSCRIPTION; -import static org.jrba.rulesengine.rest.RuleSetRestApi.getAvailableRuleSets; import static org.slf4j.LoggerFactory.getLogger; import java.util.ArrayList; import java.util.Collection; import java.util.List; +import java.util.function.BiPredicate; import org.jrba.agentmodel.domain.node.AgentNode; import org.jrba.agentmodel.domain.props.AgentProps; import org.jrba.rulesengine.RulesController; -import org.jrba.rulesengine.types.ruletype.AgentRuleType; -import org.jrba.rulesengine.types.ruletype.AgentRuleTypeEnum; import org.jrba.rulesengine.rule.AgentBasicRule; import org.jrba.rulesengine.rule.AgentRule; import org.jrba.rulesengine.rule.combined.AgentCombinedRule; import org.jrba.rulesengine.ruleset.RuleSet; +import org.jrba.rulesengine.types.ruletype.AgentRuleType; +import org.jrba.rulesengine.types.ruletype.AgentRuleTypeEnum; import org.slf4j.Logger; /** @@ -76,29 +77,31 @@ public static > RuleSet modifyBaseR public static RuleSet modifyRuleSetForName(final RuleSet baseRuleSet, final RuleSet modifications) { if (nonNull(modifications) && nonNull(baseRuleSet)) { final RuleSet baseRules = new RuleSet(baseRuleSet); - final List modificationsTypes = new ArrayList<>(modifications.getAgentRules().stream() - .map(AgentRule::getRuleType) - .toList()); + final List modificationRules = new ArrayList<>((modifications.getAgentRules())); + final BiPredicate testIfMatch = (baseRule, modificationRule) -> + baseRule.getRuleType().equals(modificationRule.getRuleType()) && + baseRule.getAgentType().equals(modificationRule.getAgentType()); baseRules.setName(modifications.getName()); - if (modificationsTypes.isEmpty()) { + if (modificationRules.isEmpty()) { return baseRules; } final List modifiableRules = baseRules.getAgentRules().stream() - .filter(agentRule -> modificationsTypes.contains(agentRule.getRuleType())) + .filter(agentRule -> modificationRules.stream().anyMatch(rule -> testIfMatch.test(agentRule, rule))) .toList(); final List usedModificationsCombined = - performModificationOfCombinedRules(modifiableRules, modifications, modificationsTypes, baseRules); + performModificationOfCombinedRules(modifiableRules, modifications, modificationRules, baseRules); final List usedModificationsStepBased = - performModificationOfStepBasedRules(modifiableRules, modifications, modificationsTypes, baseRules); + performModificationOfStepBasedRules(modifiableRules, modifications, modificationRules, baseRules); final List remainingModifications = modifications.getAgentRules().stream() - .filter(modification -> !usedModificationsCombined.contains(modification) - && !usedModificationsStepBased.contains(modification)) + .filter(modification -> !usedModificationsCombined.contains(modification) && + !usedModificationsStepBased.contains(modification)) .toList(); - baseRules.getAgentRules().removeIf(agentRule -> modificationsTypes.contains(agentRule.getRuleType())); + baseRules.getAgentRules().removeIf(agentRule -> modificationRules.stream() + .anyMatch(rule -> testIfMatch.test(agentRule, rule))); baseRules.getAgentRules().addAll(remainingModifications); return baseRules; } @@ -124,23 +127,23 @@ public static > RuleSet getRuleSetT } private static List performModificationOfCombinedRules(final List originalRules, - final RuleSet modifications, final List modificationsTypes, final RuleSet baseSet) { + final RuleSet modifications, final List modificationRules, final RuleSet baseSet) { return originalRules.stream() .filter(agentRule -> agentRule.getAgentRuleType().equals(COMBINED.getType())) .map(agentRule -> copyAndRemoveRule(agentRule, baseSet)) .map(AgentCombinedRule.class::cast) - .map(agentRule -> modifyCombinedRule(agentRule, modifications, modificationsTypes, baseSet)) + .map(agentRule -> modifyCombinedRule(agentRule, modifications, modificationRules, baseSet)) .flatMap(Collection::stream) .toList(); } private static List performModificationOfStepBasedRules(final List originalRules, - final RuleSet modifications, final List modificationsTypes, final RuleSet baseSet) { + final RuleSet modifications, final List modificationRules, final RuleSet baseSet) { return originalRules.stream() .filter(agentRule -> stepBasedRules.contains(AgentRuleTypeEnum.valueOf(agentRule.getAgentRuleType()))) .map(agentRule -> copyAndRemoveRule(agentRule, baseSet)) .map(AgentBasicRule.class::cast) - .map(agentRule -> modifyStepBasedRule(agentRule, modifications, modificationsTypes, baseSet)) + .map(agentRule -> modifyStepBasedRule(agentRule, modifications, modificationRules, baseSet)) .flatMap(Collection::stream) .toList(); } @@ -152,7 +155,7 @@ private static AgentRule copyAndRemoveRule(final AgentRule rule, final RuleSet b private static > List modifyStepBasedRule( final AgentBasicRule stepBasedRule, final RuleSet modifications, - final List modificationsTypes, final RuleSet baseSet) { + final List modificationRules, final RuleSet baseSet) { final List stepRules = stepBasedRule.getRules().stream().map(AgentRule::getStepType).toList(); final List applicableModifications = modifications.getAgentRules().stream() @@ -160,7 +163,10 @@ private static > List mo .toList(); final List consideredTypes = applicableModifications.stream().map(AgentRule::getStepType) .toList(); - consideredTypes.forEach(type -> modificationsTypes.remove(stepBasedRule.getRuleType())); + modificationRules.removeIf(agentRule -> agentRule.getRuleType().equals(stepBasedRule.getRuleType()) && + agentRule.getAgentType().equals(stepBasedRule.getAgentType()) && + nonNull(agentRule.getStepType()) && + consideredTypes.contains(agentRule.getStepType())); if (!applicableModifications.isEmpty()) { stepBasedRule.getRules().removeIf(stepRule -> consideredTypes.contains(stepRule.getStepType())); @@ -173,15 +179,19 @@ private static > List mo private static > List modifyCombinedRule( final AgentCombinedRule combinedRule, final RuleSet modifications, - final List modificationsTypes, final RuleSet baseSet) { + final List modificationRules, final RuleSet baseSet) { final List subRules = combinedRule.getNestedRules(); final List applicableModifications = modifications.getAgentRules().stream() .filter(rule -> rule.getRuleType().equals(combinedRule.getRuleType())) + .filter(rule -> rule.getAgentType().equals(combinedRule.getAgentType())) .filter(rule -> subRules.contains(rule.getSubRuleType())) .toList(); final List consideredTypes = applicableModifications.stream().map(AgentRule::getSubRuleType).toList(); - consideredTypes.forEach(type -> modificationsTypes.remove(combinedRule.getRuleType())); + modificationRules.removeIf(agentRule -> agentRule.getRuleType().equals(combinedRule.getRuleType()) && + agentRule.getAgentType().equals(combinedRule.getAgentType()) && + nonNull(agentRule.getSubRuleType()) && + consideredTypes.contains(agentRule.getSubRuleType())); if (!applicableModifications.isEmpty()) { combinedRule.getRulesToCombine().removeIf(subRule -> consideredTypes.contains(subRule.getSubRuleType()));