package husacct.validate.domain.validation.ruletype.relationruletypes;
import husacct.common.dto.DependencyDTO;
import husacct.common.dto.ModuleDTO;
import husacct.common.dto.RuleDTO;
import husacct.validate.domain.configuration.ConfigurationServiceImpl;
import husacct.validate.domain.validation.Severity;
import husacct.validate.domain.validation.Violation;
import husacct.validate.domain.validation.ViolationType;
import husacct.validate.domain.validation.internaltransferobjects.Mapping;
import husacct.validate.domain.validation.ruletype.RuleType;
import husacct.validate.domain.validation.ruletype.RuleTypes;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
public class IsNotAllowedToMakeBackCall extends RuleType {
private final static EnumSet<RuleTypes> exceptionRuleTypes = EnumSet.of(RuleTypes.IS_ALLOWED_TO_USE);
private RuleDTO currentRule;
private String logicalPathLayerFrom;
public IsNotAllowedToMakeBackCall(String key, String category, List<ViolationType> violationTypes, Severity severity) {
super(key, category, violationTypes, exceptionRuleTypes, severity);
}
@Override
public List<Violation> check(ConfigurationServiceImpl configuration, RuleDTO rule) {
violations.clear();
this.currentRule = rule;
this.logicalPathLayerFrom = currentRule.moduleFrom.logicalPath;
fromMappings = getAllClasspathsOfModule(currentRule.moduleFrom, currentRule.violationTypeKeys);
List<ModuleDTO> brotherModules = Arrays.asList(defineService.getModule_TheChildrenOfTheModule(defineService.getModule_TheParentOfTheModule(logicalPathLayerFrom)));
List<ModuleDTO> potentialLayersToBeBackCalled = selectPotentialLayersToBeBackCalled(brotherModules);
if(potentialLayersToBeBackCalled.size() >= 1){
List<Mapping> modulesTo = new ArrayList<Mapping>();
for(ModuleDTO layerTo : potentialLayersToBeBackCalled){
modulesTo.addAll(getAllClasspathsOfModule(layerTo, currentRule.violationTypeKeys));
}
// Create a HashMap with all allowed from-to combinations, based on the exception rules.
HashSet<String> allExceptionFromTos = getAllExceptionFromTos(currentRule);
for (Mapping classPathFrom : fromMappings) {
for (Mapping classPathTo : modulesTo) {
String fromToCombi = classPathFrom.getPhysicalPath() + "|" + classPathTo.getPhysicalPath();
if (allExceptionFromTos.contains(fromToCombi)){
// Do not add violations, since this usage is allowed.
} else{
DependencyDTO[] violatingDependencies = analyseService.getDependenciesFromClassToClass(classPathFrom.getPhysicalPath(), classPathTo.getPhysicalPath());
if(violatingDependencies != null){
for(DependencyDTO dependency : violatingDependencies){
Violation violation = createViolation(rule, dependency, configuration);
violations.add(violation);
}
}
}
}
}
}
return violations;
}
private List<ModuleDTO> selectPotentialLayersToBeBackCalled(List<ModuleDTO> allModules) {
List<ModuleDTO> returnModules = new ArrayList<>();
int hierarchicalLevelModuleFrom = defineService.getHierarchicalLevelOfLayer(logicalPathLayerFrom);
int lowestBackCallLevel = hierarchicalLevelModuleFrom -1;
for (ModuleDTO module : allModules) {
if (module.type.toLowerCase().equalsIgnoreCase("layer")){
int hierarchicalLevel = defineService.getHierarchicalLevelOfLayer(module.logicalPath);
if(hierarchicalLevel <= lowestBackCallLevel) {
returnModules.add(module);
}
}
}
return returnModules;
}
}