RuleActivatorContext setParentActiveRuleParams(@Nullable Collection<ActiveRuleParamDto> a) {
parentActiveRuleParams.clear();
if (a != null) {
for (ActiveRuleParamDto ar : a) {
this.parentActiveRuleParams.put(ar.getKey(), ar);
}
}
return this;
}
boolean isSame(ActiveRuleChange change) {
ActiveRule.Inheritance inheritance = change.getInheritance();
if (inheritance != null && !inheritance.name().equals(activeRule.getInheritance())) {
return false;
}
String severity = change.getSeverity();
if (severity != null && !severity.equals(activeRule.getSeverityString())) {
return false;
}
for (Map.Entry<String, String> changeParam : change.getParameters().entrySet()) {
ActiveRuleParamDto param = activeRuleParams.get(changeParam.getKey());
if (param != null && !StringUtils.equals(changeParam.getValue(), param.getValue())) {
return false;
}
}
return true;
}
private ActiveRuleDto persist(
ActiveRuleChange change, RuleActivatorContext context, DbSession dbSession) {
ActiveRuleDao dao = db.activeRuleDao();
ActiveRuleDto activeRule = null;
if (change.getType() == ActiveRuleChange.Type.ACTIVATED) {
activeRule = ActiveRuleDto.createFor(context.profile(), context.rule());
activeRule.setSeverity(change.getSeverity());
if (change.getInheritance() != null) {
activeRule.setInheritance(change.getInheritance().name());
}
dao.insert(dbSession, activeRule);
for (Map.Entry<String, String> param : change.getParameters().entrySet()) {
if (param.getValue() != null) {
ActiveRuleParamDto paramDto =
ActiveRuleParamDto.createFor(context.ruleParamsByKeys().get(param.getKey()));
paramDto.setValue(param.getValue());
dao.addParam(dbSession, activeRule, paramDto);
}
}
} else if (change.getType() == ActiveRuleChange.Type.DEACTIVATED) {
dao.deleteByKey(dbSession, change.getKey());
} else if (change.getType() == ActiveRuleChange.Type.UPDATED) {
activeRule = context.activeRule();
activeRule.setSeverity(change.getSeverity());
if (change.getInheritance() != null) {
activeRule.setInheritance(change.getInheritance().name());
}
dao.update(dbSession, activeRule);
for (Map.Entry<String, String> param : change.getParameters().entrySet()) {
ActiveRuleParamDto activeRuleParamDto = context.activeRuleParamsAsMap().get(param.getKey());
if (activeRuleParamDto == null) {
// did not exist
if (param.getValue() != null) {
activeRuleParamDto =
ActiveRuleParamDto.createFor(context.ruleParamsByKeys().get(param.getKey()));
activeRuleParamDto.setValue(param.getValue());
dao.addParam(dbSession, activeRule, activeRuleParamDto);
}
} else {
if (param.getValue() != null) {
activeRuleParamDto.setValue(param.getValue());
dao.updateParam(dbSession, activeRule, activeRuleParamDto);
} else {
dao.deleteParam(dbSession, activeRule, activeRuleParamDto);
}
}
}
}
return activeRule;
}
@CheckForNull
String parentParamValue(String key) {
ActiveRuleParamDto param = parentActiveRuleParams.get(key);
return param != null ? param.getValue() : null;
}
@Override
public ProjectReferentials load(ProjectReactor reactor, Settings settings, Languages languages) {
ProjectReferentials ref = new ProjectReferentials();
String defaultName = settings.getString(ModuleQProfiles.SONAR_PROFILE_PROP);
for (Language language : languages.all()) {
org.sonar.batch.protocol.input.QProfile profile = null;
if (StringUtils.isNotBlank(defaultName)) {
profile = loadDefaultQProfile(defaultName, language.getKey());
}
if (profile == null) {
profile = loadQProfile(settings, language.getKey());
}
if (profile != null) {
ref.addQProfile(profile);
}
}
for (QProfile qProfile : ref.qProfiles()) {
ListMultimap<Integer, ActiveRuleParamDto> paramDtosByActiveRuleId =
ArrayListMultimap.create();
for (ActiveRuleParamDto dto : activeRuleDao.selectParamsByProfileKey(qProfile.key())) {
paramDtosByActiveRuleId.put(dto.getActiveRuleId(), dto);
}
for (ActiveRuleDto activeDto : activeRuleDao.selectByProfileKey(qProfile.key())) {
Rule rule = ruleFinder.findById(activeDto.getRuleId());
if (rule != null) {
String internalKey;
Rule template = rule.getTemplate();
if (template != null) {
internalKey = template.getConfigKey();
} else {
internalKey = rule.getConfigKey();
}
ActiveRule activeRule =
new ActiveRule(
rule.ruleKey().repository(),
rule.ruleKey().rule(),
rule.getName(),
activeDto.getSeverityString(),
internalKey,
rule.getLanguage());
// load parameter values
for (ActiveRuleParamDto paramDto : paramDtosByActiveRuleId.get(activeDto.getId())) {
activeRule.params().put(paramDto.getKey(), paramDto.getValue());
}
// load default values
for (RuleParam param : rule.getParams()) {
if (!activeRule.params().containsKey(param.getKey())) {
activeRule.params().put(param.getKey(), param.getDefaultValue());
}
}
ref.addActiveRule(activeRule);
}
}
}
return ref;
}