public ValidationMessages changeParentProfile( Integer profileId, String parentName, String userName) { ValidationMessages messages = ValidationMessages.create(); RulesProfile profile = getSession().getEntity(RulesProfile.class, profileId); if (profile != null && !profile.getProvided()) { RulesProfile oldParent = getParentProfile(profile); RulesProfile newParent = getProfile(profile.getLanguage(), parentName); if (isCycle(profile, newParent)) { messages.addWarningText("Please do not select a child profile as parent."); return messages; } // Deactivate all inherited rules if (oldParent != null) { for (ActiveRule activeRule : oldParent.getActiveRules()) { deactivate(profile, activeRule.getRule(), userName); } } // Activate all inherited rules if (newParent != null) { for (ActiveRule activeRule : newParent.getActiveRules()) { activateOrChange(profile, activeRule, userName); } } profile.setParentName(newParent == null ? null : newParent.getName()); getSession().saveWithoutFlush(profile); getSession().commit(); } return messages; }
/** Rule was deactivated in parent profile. */ public void deactivated(int parentProfileId, int deactivatedRuleId, String userName) { ActiveRule parentActiveRule = getSession().getEntity(ActiveRule.class, deactivatedRuleId); RulesProfile profile = getSession().getEntity(RulesProfile.class, parentProfileId); ruleDisabled(profile, parentActiveRule, userName); for (RulesProfile child : getChildren(parentProfileId)) { deactivate(child, parentActiveRule.getRule(), userName); } getSession().commit(); }
/** Rule was activated/changed in parent profile. */ private void activatedOrChanged(int parentProfileId, int activeRuleId, String userName) { ActiveRule parentActiveRule = getSession().getEntity(ActiveRule.class, activeRuleId); if (parentActiveRule.isInherited()) { parentActiveRule.setInheritance(ActiveRule.OVERRIDES); getSession().saveWithoutFlush(parentActiveRule); } for (RulesProfile child : getChildren(parentProfileId)) { activateOrChange(child, parentActiveRule, userName); } getSession().commit(); }
private void activateOrChange( RulesProfile profile, ActiveRule parentActiveRule, String userName) { ActiveRule oldActiveRule = profile.getActiveRule(parentActiveRule.getRule()); if (oldActiveRule != null) { if (oldActiveRule.isInherited()) { removeActiveRule(profile, oldActiveRule); } else { oldActiveRule.setInheritance(ActiveRule.OVERRIDES); getSession().saveWithoutFlush(oldActiveRule); return; // no need to change in children } } ActiveRule newActiveRule = (ActiveRule) parentActiveRule.clone(); newActiveRule.setRulesProfile(profile); newActiveRule.setInheritance(ActiveRule.INHERITED); profile.addActiveRule(newActiveRule); getSession().saveWithoutFlush(newActiveRule); if (oldActiveRule != null) { ruleChanged(profile, oldActiveRule, newActiveRule, userName); } else { ruleEnabled(profile, newActiveRule, userName); } for (RulesProfile child : getChildren(profile)) { activateOrChange(child, newActiveRule, userName); } }
/** Rule severity was changed */ public void ruleSeverityChanged( int profileId, int activeRuleId, RulePriority oldSeverity, RulePriority newSeverity, String userName) { ActiveRule activeRule = getSession().getEntity(ActiveRule.class, activeRuleId); RulesProfile profile = getSession().getEntity(RulesProfile.class, profileId); ruleSeverityChanged(profile, activeRule.getRule(), oldSeverity, newSeverity, userName); // Notify child profiles activatedOrChanged(profileId, activeRuleId, userName); }
/** Deal with creation of ActiveRuleChange item when a rule is disabled on a profile */ private void ruleDisabled(RulesProfile profile, ActiveRule disabledRule, String userName) { incrementProfileVersionIfNeeded(profile); ActiveRuleChange rc = new ActiveRuleChange(userName, profile, disabledRule.getRule()); rc.setEnabled(false); rc.setOldSeverity(disabledRule.getSeverity()); if (disabledRule.getRule().getParams() != null) { for (RuleParam p : disabledRule.getRule().getParams()) { String oldParam = disabledRule.getParameter(p.getKey()); if (oldParam != null) { rc.setParameterChange(p.getKey(), oldParam, null); } } } getSession().saveWithoutFlush(rc); }
/** Deal with creation of ActiveRuleChange item when a rule is enabled on a profile */ private void ruleEnabled(RulesProfile profile, ActiveRule newActiveRule, String userName) { incrementProfileVersionIfNeeded(profile); ActiveRuleChange rc = new ActiveRuleChange(userName, profile, newActiveRule.getRule()); rc.setEnabled(true); rc.setNewSeverity(newActiveRule.getSeverity()); if (newActiveRule.getRule().getParams() != null) { for (RuleParam p : newActiveRule.getRule().getParams()) { String newParam = newActiveRule.getParameter(p.getKey()); if (newParam != null) { rc.setParameterChange(p.getKey(), null, newParam); } } } getSession().saveWithoutFlush(rc); }
/** Rule param was changed */ public void ruleParamChanged( int profileId, int activeRuleId, String paramKey, String oldValue, String newValue, String userName) { ActiveRule activeRule = getSession().getEntity(ActiveRule.class, activeRuleId); RulesProfile profile = getSession().getEntity(RulesProfile.class, profileId); ruleParamChanged(profile, activeRule.getRule(), paramKey, oldValue, newValue, userName); // Notify child profiles activatedOrChanged(profileId, activeRuleId, userName); }
private void deactivate(RulesProfile profile, Rule rule, String userName) { ActiveRule activeRule = profile.getActiveRule(rule); if (activeRule != null) { if (activeRule.isInherited()) { ruleDisabled(profile, activeRule, userName); removeActiveRule(profile, activeRule); } else { activeRule.setInheritance(null); getSession().saveWithoutFlush(activeRule); return; // no need to change in children } for (RulesProfile child : getChildren(profile)) { deactivate(child, rule, userName); } } }
private List<ProfileDefinition> loadFromDeprecatedRepository(RulesRepository repository) { List<ProfileDefinition> result = new ArrayList<ProfileDefinition>(); for (int index = 0; index < repository.getProvidedProfiles().size(); index++) { RulesProfile deprecated = (RulesProfile) repository.getProvidedProfiles().get(index); DefaultProfileDefinition providedProfile = DefaultProfileDefinition.create(deprecated.getName(), repository.getLanguage().getKey()); for (ActiveRule deprecatedActiveRule : deprecated.getActiveRules(true)) { String repositoryKey = deprecatedActiveRule.getRepositoryKey(); if (StringUtils.isBlank(repositoryKey)) { repositoryKey = getPluginKey(repository); } Rule rule = ruleFinder.findByKey(repositoryKey, deprecatedActiveRule.getRuleKey()); if (rule != null) { ActiveRule activeRule = providedProfile.activateRule(rule, deprecatedActiveRule.getSeverity()); for (ActiveRuleParam arp : deprecatedActiveRule.getActiveRuleParams()) { activeRule.setParameter(arp.getKey(), arp.getValue()); } } } result.add(providedProfile); } return result; }
private ProfileDefinition loadFromDeprecatedCheckProfile(CheckProfile cp) { DefaultProfileDefinition definition = DefaultProfileDefinition.create(cp.getName(), cp.getLanguage()); for (Check check : cp.getChecks()) { RulePriority priority = null; if (check.getPriority() != null) { priority = RulePriority.fromCheckPriority(check.getPriority()); } Rule rule = ruleFinder.findByKey(check.getRepositoryKey(), check.getTemplateKey()); if (rule != null) { ActiveRule activeRule = definition.activateRule(rule, priority); for (Map.Entry<String, String> entry : check.getProperties().entrySet()) { activeRule.setParameter(entry.getKey(), entry.getValue()); } } } return definition; }
private void importActiveRules(RulesDao rulesDao, RulesProfile profile) { for (Iterator<ActiveRule> iar = profile.getActiveRules(true).iterator(); iar.hasNext(); ) { ActiveRule activeRule = iar.next(); Rule unMarshalledRule = activeRule.getRule(); Rule matchingRuleInDb = rulesDao.getRuleByKey(unMarshalledRule.getRepositoryKey(), unMarshalledRule.getKey()); if (matchingRuleInDb == null) { LoggerFactory.getLogger(getClass()) .error( "Unable to find active rule " + unMarshalledRule.getRepositoryKey() + ":" + unMarshalledRule.getKey()); iar.remove(); continue; } activeRule.setRule(matchingRuleInDb); activeRule.setRulesProfile(profile); activeRule.getActiveRuleParams(); for (Iterator<ActiveRuleParam> irp = activeRule.getActiveRuleParams().iterator(); irp.hasNext(); ) { ActiveRuleParam activeRuleParam = irp.next(); RuleParam unMarshalledRP = activeRuleParam.getRuleParam(); RuleParam matchingRPInDb = rulesDao.getRuleParam(matchingRuleInDb, unMarshalledRP.getKey()); if (matchingRPInDb == null) { LoggerFactory.getLogger(getClass()) .error("Unable to find active rule parameter " + unMarshalledRP.getKey()); irp.remove(); continue; } activeRuleParam.setActiveRule(activeRule); activeRuleParam.setRuleParam(matchingRPInDb); } } }
private void verifyOneActiveRule( String profileKey, String expectedSeverity, @Nullable String expectedInheritance, Map<String, String> expectedParams) { List<ActiveRule> activeRules = Lists.newArrayList(index.findByProfile(profileKey)); assertThat(activeRules).hasSize(1); ActiveRule activeRule = activeRules.get(0); assertThat(activeRule.severity()).isEqualTo(expectedSeverity); assertThat(activeRule.inheritance()) .isEqualTo( expectedInheritance == null ? ActiveRule.Inheritance.NONE : ActiveRule.Inheritance.valueOf(expectedInheritance)); // verify parameters assertThat(activeRule.params()).hasSize(expectedParams.size()); for (Map.Entry<String, String> entry : expectedParams.entrySet()) { String value = activeRule.params().get(entry.getKey()); assertThat(value).isEqualTo(entry.getValue()); } }
/** * Deal with creation of ActiveRuleChange item when a rule is changed (severity and/or param(s)) * on a profile */ private void ruleChanged( RulesProfile profile, ActiveRule oldActiveRule, ActiveRule newActiveRule, String userName) { incrementProfileVersionIfNeeded(profile); ActiveRuleChange rc = new ActiveRuleChange(userName, profile, newActiveRule.getRule()); if (oldActiveRule.getSeverity() != newActiveRule.getSeverity()) { rc.setOldSeverity(oldActiveRule.getSeverity()); rc.setNewSeverity(newActiveRule.getSeverity()); } if (oldActiveRule.getRule().getParams() != null) { for (RuleParam p : oldActiveRule.getRule().getParams()) { String oldParam = oldActiveRule.getParameter(p.getKey()); String newParam = newActiveRule.getParameter(p.getKey()); if (!StringUtils.equals(oldParam, newParam)) { rc.setParameterChange(p.getKey(), oldParam, newParam); } } } getSession().saveWithoutFlush(rc); }
public void revert(int profileId, int activeRuleId, String userName) { RulesProfile profile = getSession().getEntity(RulesProfile.class, profileId); ActiveRule oldActiveRule = getSession().getEntity(ActiveRule.class, activeRuleId); if (oldActiveRule != null && oldActiveRule.doesOverride()) { ActiveRule parentActiveRule = getParentProfile(profile).getActiveRule(oldActiveRule.getRule()); removeActiveRule(profile, oldActiveRule); ActiveRule newActiveRule = (ActiveRule) parentActiveRule.clone(); newActiveRule.setRulesProfile(profile); newActiveRule.setInheritance(ActiveRule.INHERITED); profile.addActiveRule(newActiveRule); getSession().saveWithoutFlush(newActiveRule); // Compute change ruleChanged(profile, oldActiveRule, newActiveRule, userName); for (RulesProfile child : getChildren(profile)) { activateOrChange(child, newActiveRule, userName); } getSession().commit(); } }