boolean isEnabled(String programmingLanguage, String ruleTypeKey, String violationTypeKey) {
List<ActiveRuleType> activeRuleTypes =
this.currentActiveViolationTypes.get(programmingLanguage);
if (activeRuleTypes != null) {
for (ActiveRuleType activeRuleType : activeRuleTypes) {
if (activeRuleType.getRuleType().toLowerCase().equals(ruleTypeKey.toLowerCase())) {
if (activeRuleType.getViolationTypes().isEmpty()) {
return false;
}
for (ActiveViolationType activeViolationType : activeRuleType.getViolationTypes()) {
if (activeViolationType
.getType()
.toLowerCase()
.equals(violationTypeKey.toLowerCase())) {
return activeViolationType.isEnabled();
}
}
}
}
} else {
throw new ProgrammingLanguageNotFoundException();
}
return false;
}
private ActiveRuleType containsRuleType(
List<ActiveRuleType> activeRuleTypes, String ruleTypeKey) {
for (ActiveRuleType activeRuleType : activeRuleTypes) {
if (activeRuleType.getRuleType().equals(ruleTypeKey)) {
return activeRuleType;
}
}
throw new RuntimeException();
}
private boolean ruleTypeKeyExists(String programmingLanguage, String ruleTypeKey) {
if (programmingLanguageExists(programmingLanguage)) {
for (ActiveRuleType activeRuleType : startupViolationTypes.get(programmingLanguage)) {
if (activeRuleType.getRuleType().toLowerCase().equals(ruleTypeKey.toLowerCase())) {
return true;
}
}
} else {
throw new ProgrammingLanguageNotFoundException(programmingLanguage);
}
throw new RuleTypeNotFoundException(ruleTypeKey);
}
private ActiveRuleType initializeActiveViolationTypes(RuleType ruleType) {
final String ruleTypeKey = ruleType.getKey();
List<ActiveViolationType> initialActiveViolationTypes = new ArrayList<ActiveViolationType>();
for (ViolationType violationType : ruleType.getViolationTypes()) {
final String violationTypeKey = violationType.getViolationtypeKey();
boolean enabled = violationType.isActive();
ActiveViolationType activeViolationType = new ActiveViolationType(violationTypeKey, enabled);
initialActiveViolationTypes.add(activeViolationType);
}
ActiveRuleType activeRuleType = new ActiveRuleType(ruleTypeKey);
activeRuleType.setViolationTypes(initialActiveViolationTypes);
return activeRuleType;
}
private boolean violationTypeKeyExists(
String programmingLanguage, String ruleTypeKey, String violationTypeKey) {
if (programmingLanguageExists(programmingLanguage)
&& ruleTypeKeyExists(programmingLanguage, ruleTypeKey)) {
for (ActiveRuleType activeRuleType : startupViolationTypes.get(programmingLanguage)) {
for (ActiveViolationType activeViolationType : activeRuleType.getViolationTypes()) {
if (activeViolationType.getType().toLowerCase().equals(violationTypeKey.toLowerCase())) {
return true;
}
}
}
}
throw new ViolationTypeNotFoundException(violationTypeKey);
}
private List<ActiveRuleType> mergeNewViolationTypes(
String programmingLanguage, List<ActiveRuleType> newActiveViolationTypes) {
List<ActiveRuleType> activeViolationTypesForLanguage = new ArrayList<ActiveRuleType>();
for (ActiveRuleType currentActiveRuleType : startupViolationTypes.get(programmingLanguage)) {
try {
ActiveRuleType existingActiveRuleType =
containsRuleType(newActiveViolationTypes, currentActiveRuleType.getRuleType());
List<ActiveViolationType> activeViolationTypes = new ArrayList<ActiveViolationType>();
for (ActiveViolationType currentActiveViolationType :
containsRuleType(
startupViolationTypes.get(programmingLanguage),
existingActiveRuleType.getRuleType())
.getViolationTypes()) {
boolean found = false;
for (ActiveViolationType newViolationType : existingActiveRuleType.getViolationTypes()) {
if (newViolationType.getType().equals(currentActiveViolationType.getType())) {
activeViolationTypes.add(newViolationType);
found = true;
}
}
if (!found) {
activeViolationTypes.add(
new ActiveViolationType(
currentActiveViolationType.getType(), currentActiveViolationType.isEnabled()));
}
}
activeViolationTypesForLanguage.add(
new ActiveRuleType(existingActiveRuleType.getRuleType(), activeViolationTypes));
} catch (RuntimeException e) {
List<ActiveViolationType> activeViolationTypes = new ArrayList<ActiveViolationType>();
for (ActiveViolationType activeViolationType : currentActiveRuleType.getViolationTypes()) {
activeViolationTypes.add(
new ActiveViolationType(
activeViolationType.getType(), activeViolationType.isEnabled()));
}
ActiveRuleType activeRuleType =
new ActiveRuleType(currentActiveRuleType.getRuleType(), activeViolationTypes);
activeViolationTypesForLanguage.add(activeRuleType);
}
}
return activeViolationTypesForLanguage;
}
private List<ActiveRuleType> checkNewActiveViolationTypes(
String programmingLanguage, List<ActiveRuleType> newActiveViolationTypes) {
List<ActiveRuleType> activeViolationTypesForLanguage = new ArrayList<ActiveRuleType>();
for (ActiveRuleType newActiveRuleType : newActiveViolationTypes) {
if (ruleTypeKeyExists(programmingLanguage, newActiveRuleType.getRuleType())) {
List<ActiveViolationType> activeViolationTypes = new ArrayList<ActiveViolationType>();
ActiveRuleType activeRuleType = new ActiveRuleType(newActiveRuleType.getRuleType());
activeRuleType.setViolationTypes(activeViolationTypes);
boolean foundViolationTypeKey = false;
for (ActiveViolationType newActiveViolationType : newActiveRuleType.getViolationTypes()) {
if (violationTypeKeyExists(
programmingLanguage,
newActiveRuleType.getRuleType(),
newActiveViolationType.getType())) {
foundViolationTypeKey = true;
activeViolationTypes.add(
new ActiveViolationType(
newActiveViolationType.getType(), newActiveViolationType.isEnabled()));
} else {
logger.debug(
String.format("violationTypeKey %s not exists", newActiveViolationType.getType()));
}
}
if (foundViolationTypeKey) {
activeViolationTypesForLanguage.add(activeRuleType);
}
} else {
logger.debug(
String.format(
"ruleTypeKey %s not exists in programminglanguage %s",
newActiveRuleType.getRuleType(), programmingLanguage));
}
}
return mergeNewViolationTypes(programmingLanguage, activeViolationTypesForLanguage);
}