Revize 38cde13c

#14 Adding possibilty to use configurations from external files in analyzing

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/controller/AppController.java

@@ -118 +118 @@
     @PostMapping("/analyze")
     public String analyze(Model model,
                           @RequestParam(value = "selectedProjects", required = false) String[] selectedProjects,
-                          @RequestParam(value = "selectedAntiPatterns", required = false) String[] selectedAntiPatterns
+                          @RequestParam(value = "selectedAntiPatterns", required = false) String[] selectedAntiPatterns,
+                          HttpSession session
     ) {
 
         if (selectedProjects == null) {
@@ -135 +136 @@
             return "index";
         }
 
-        List<QueryResult> results = antiPatternManager.analyze(selectedProjects, selectedAntiPatterns);
+        String currentConfigurationName = configurationGetFromSession(session);
+        Map<String, Map<String, String>> currentConfiguration = configurationService.getConfigurationByName(currentConfigurationName);
+
+        List<QueryResult> results = antiPatternManager.analyze(selectedProjects, selectedAntiPatterns, currentConfiguration);
         antiPatternService.saveAnalyzedProjects(selectedProjects, selectedAntiPatterns);
         antiPatternService.saveResults(results);
         antiPatternService.setConfigurationChanged(false);
@@ -186 +190 @@
     public String resultRecalculate(Model model) {
 
         List<QueryResult> results = antiPatternManager.analyze(antiPatternService.getAnalyzedProjects(),
-                antiPatternService.getAnalyzedAntiPatterns());
+                antiPatternService.getAnalyzedAntiPatterns(), null);
 
         antiPatternService.saveResults(results);
         antiPatternService.setConfigurationChanged(false);
@@ -426 +430 @@
         if(session.getAttribute("configuration") != null)
             return session.getAttribute("configuration").toString(); // return configuration stored in session
         else{
-            List<String> configurationList = configurationService.getAllConfigurationNames();
+            List<String> configurationList = configurationService.getDefaultConfigurationNames();
             if(configurationList.size() == 0)
                 return null;
 

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/detecting/AntiPatternManager.java

@@ -4 +4 @@
 import cz.zcu.fav.kiv.antipatterndetectionapp.model.QueryResult;
 
 import java.util.List;
+import java.util.Map;
 
 public interface AntiPatternManager {
 
-    List<QueryResult> analyze(String[] selectedProjects, String[] selectedAntiPatterns);
+    List<QueryResult> analyze(String[] selectedProjects, String[] selectedAntiPatterns, Map<String, Map<String, String>> configuration);
 }

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/detecting/AntiPatternManagerImpl.java

@@ -13 +13 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 @Service
 public class AntiPatternManagerImpl implements AntiPatternManager {
@@ -24 +25 @@
     private AntiPatternService antiPatternService;
 
     @Override
-    public List<QueryResult> analyze(String[] selectedProjects, String[] selectedAntiPatterns) {
+    public List<QueryResult> analyze(String[] selectedProjects, String[] selectedAntiPatterns, Map<String, Map<String, String>> configuration) {
 
         return this.analyze(projectService.getAllProjectsForGivenIds(Utils.arrayOfStringsToArrayOfLongs(selectedProjects)),
-                antiPatternService.getAllAntiPatternsForGivenIds(Utils.arrayOfStringsToArrayOfLongs(selectedAntiPatterns)));
+                antiPatternService.getAllAntiPatternsForGivenIds(Utils.arrayOfStringsToArrayOfLongs(selectedAntiPatterns)), configuration);
     }
 
     /**
@@ -36 +37 @@
      * @param antiPatternDetectors Ap detectoros
      * @return List of results
      */
-    private List<QueryResult> analyze(List<Project> projects, List<AntiPatternDetector> antiPatternDetectors) {
+    private List<QueryResult> analyze(List<Project> projects, List<AntiPatternDetector> antiPatternDetectors, Map<String, Map<String, String>> configuration) {
         DatabaseConnection databaseConnection = new DatabaseConnection();
 
         List<QueryResult> queryResults = new ArrayList<>();
@@ -46 +47 @@
             QueryResult queryResult = new QueryResult();
             queryResult.setProject(project);
             List<QueryResultItem> queryResultItems = new ArrayList<>();
+
             for (AntiPatternDetector antiPattern : antiPatternDetectors) {
-                queryResultItems.add(antiPattern.analyze(project, databaseConnection));
+                String antiPatternName = antiPattern.getAntiPatternModel().getName();
+
+                Map<String, String> thresholds = null;
+
+                if(configuration != null)
+                    thresholds = configuration.get(antiPatternName);
+
+                queryResultItems.add(antiPattern.analyze(project, databaseConnection, thresholds));
             }
             queryResult.setQueryResultItems(queryResultItems);
             queryResults.add(queryResult);

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/detecting/detectors/AntiPatternDetector.java

@@ -4 +4 @@
 import cz.zcu.fav.kiv.antipatterndetectionapp.model.AntiPattern;
 import cz.zcu.fav.kiv.antipatterndetectionapp.model.Project;
 import cz.zcu.fav.kiv.antipatterndetectionapp.model.QueryResultItem;
-import cz.zcu.fav.kiv.antipatterndetectionapp.utils.Utils;
 
 import java.util.List;
+import java.util.Map;
 
 /**
  * This is base interface for all AP detector. In case you need to implement new AP detector
@@ -57 +57 @@
      * @param databaseConnection database connection
      * @return model class for results
      */
-    QueryResultItem analyze(Project project, DatabaseConnection databaseConnection);
+    QueryResultItem analyze(Project project, DatabaseConnection databaseConnection, Map<String, String> thresholds);
 }

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/detecting/detectors/BusinessAsUsualDetectorImpl.java

@@ -28 +28 @@
     // sql queries loaded from sql file
     private List<String> sqlQueries;
 
-    private float getDivisionOfIterationsWithRetrospective() {
+    private float getDivisionOfIterationsWithRetrospective(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return new Percentage(Float.parseFloat(thresholds.get("divisionOfIterationsWithRetrospective"))).getValue();
+
         return ((Percentage) antiPattern.getThresholds().get("divisionOfIterationsWithRetrospective").getValue()).getValue();
     }
 
-    private List<String> getSearchSubstringsWithRetrospective() {
+    private List<String> getSearchSubstringsWithRetrospective(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return Arrays.asList(thresholds.get("searchSubstringsWithRetrospective").split("\\|\\|"));
+
         return Arrays.asList(((String) antiPattern.getThresholds().get("searchSubstringsWithRetrospective").getValue()).split("\\|\\|"));
     }
 
@@ -78 +84 @@
      * @return results of detection
      */
     @Override
-    public QueryResultItem analyze(Project project, DatabaseConnection databaseConnection) {
+    public QueryResultItem analyze(Project project, DatabaseConnection databaseConnection, Map<String, String> thresholds) {
 
         // init values
         List<ResultDetail> resultDetails = new ArrayList<>();
@@ -87 +93 @@
 
         // go through the results of the queries and put in one map => in this map should be all iterations
         List<List<Map<String, Object>>> resultSets = databaseConnection.executeQueriesWithMultipleResults(project,
-                Utils.fillQueryWithSearchSubstrings(this.sqlQueries, getSearchSubstringsWithRetrospective()));
+                Utils.fillQueryWithSearchSubstrings(this.sqlQueries, getSearchSubstringsWithRetrospective(thresholds)));
         for (int i = 0; i < resultSets.size(); i++) {
             List<Map<String, Object>> rs = resultSets.get(i);
 
@@ -113 +119 @@
 
         }
 
-        int minRetrospectiveLimit = Math.round(totalNumberIterations * getDivisionOfIterationsWithRetrospective());
+        int minRetrospectiveLimit = Math.round(totalNumberIterations * getDivisionOfIterationsWithRetrospective(thresholds));
 
         resultDetails.add(new ResultDetail("Min retrospective limit", String.valueOf(minRetrospectiveLimit)));
         resultDetails.add(new ResultDetail("Found retrospectives", String.valueOf(iterationsResults.size())));

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/detecting/detectors/LongOrNonExistentFeedbackLoopsDetectorImpl.java

@@ -35 +35 @@
     // sql queries loaded from sql file
     private List<String> sqlQueries;
 
-    private float getDivisionOfIterationsWithFeedbackLoop() {
+    private float getDivisionOfIterationsWithFeedbackLoop(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return new Percentage(Float.parseFloat(thresholds.get("divisionOfIterationsWithFeedbackLoop"))).getValue();
+
         return ((Percentage) antiPattern.getThresholds().get("divisionOfIterationsWithFeedbackLoop").getValue()).getValue();
     }
 
-    private float getMaxGapBetweenFeedbackLoopRate() {
+    private float getMaxGapBetweenFeedbackLoopRate(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return new PositiveFloat(Float.parseFloat(thresholds.get("maxGapBetweenFeedbackLoopRate"))).floatValue();
+
         return ((PositiveFloat) antiPattern.getThresholds().get("maxGapBetweenFeedbackLoopRate").getValue()).floatValue();
     }
 
-    private List<String> getSearchSubstringsWithFeedbackLoop() {
+    private List<String> getSearchSubstringsWithFeedbackLoop(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return Arrays.asList(thresholds.get("searchSubstringsWithFeedbackLoop").split("\\|\\|"));
+
         return Arrays.asList(((String) antiPattern.getThresholds().get("searchSubstringsWithFeedbackLoop").getValue()).split("\\|\\|"));
     }
 
@@ -92 +101 @@
      * @return detection result
      */
     @Override
-    public QueryResultItem analyze(Project project, DatabaseConnection databaseConnection) {
+    public QueryResultItem analyze(Project project, DatabaseConnection databaseConnection, Map<String, String> thresholds) {
 
         // init values
         long totalNumberIterations = 0;
@@ -105 +114 @@
         Date projectEndDate = null;
 
         List<List<Map<String, Object>>> resultSets = databaseConnection.executeQueriesWithMultipleResults(project,
-                Utils.fillQueryWithSearchSubstrings(this.sqlQueries, getSearchSubstringsWithFeedbackLoop()));
+                Utils.fillQueryWithSearchSubstrings(this.sqlQueries, getSearchSubstringsWithFeedbackLoop(thresholds)));
         for (int i = 0; i < resultSets.size(); i++) {
             List<Map<String, Object>> rs = resultSets.get(i);
 
@@ -147 +156 @@
             }
         }
 
-        double halfNumberOfIterations = totalNumberIterations * getDivisionOfIterationsWithFeedbackLoop();
+        double halfNumberOfIterations = totalNumberIterations * getDivisionOfIterationsWithFeedbackLoop(thresholds);
 
         // if the number of iterations that contain at least one feedback activity is the ideal case
         if (totalNumberIterations <= numberOfIterationsWhichContainsAtLeastOneActivityForFeedback) {
@@ -170 +179 @@
                 long daysBetween = Utils.daysBetween(firstDate, secondDate);
                 firstDate = secondDate;
 
-                if (daysBetween >= getMaxGapBetweenFeedbackLoopRate() * averageIterationLength) {
+                if (daysBetween >= getMaxGapBetweenFeedbackLoopRate(thresholds) * averageIterationLength) {
                     List<ResultDetail> resultDetails = Utils.createResultDetailsList(
                             new ResultDetail("Days between", Long.toString(daysBetween)),
                             new ResultDetail("Average iteration length", Integer.toString(averageIterationLength)),
@@ -211 +220 @@
                 long daysBetween = Utils.daysBetween(firstDate, secondDate);
                 firstDate = secondDate;
 
-                if (daysBetween >= getMaxGapBetweenFeedbackLoopRate() * averageIterationLength) {
+                if (daysBetween >= getMaxGapBetweenFeedbackLoopRate(thresholds) * averageIterationLength) {
                     List<ResultDetail> resultDetails = Utils.createResultDetailsList(
                             new ResultDetail("Days between", Long.toString(daysBetween)),
                             new ResultDetail("Average iteration length", Integer.toString(averageIterationLength)),

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/detecting/detectors/NinetyNinetyRuleDetectorImpl.java

@@ -2 +2 @@
 
 import cz.zcu.fav.kiv.antipatterndetectionapp.detecting.DatabaseConnection;
 import cz.zcu.fav.kiv.antipatterndetectionapp.model.*;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.types.Percentage;
 import cz.zcu.fav.kiv.antipatterndetectionapp.model.types.PositiveFloat;
 import cz.zcu.fav.kiv.antipatterndetectionapp.model.types.PositiveInteger;
 import cz.zcu.fav.kiv.antipatterndetectionapp.service.AntiPatternService;
@@ -26 +27 @@
     // sql queries loaded from sql file
     private List<String> sqlQueries;
 
-    private double getMaxDivisionRange() {
+    private double getMaxDivisionRange(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return new PositiveFloat(Float.parseFloat(thresholds.get("maxDivisionRange"))).floatValue();
+
         return ((PositiveFloat) antiPattern.getThresholds().get("maxDivisionRange").getValue()).doubleValue();
     }
 
-    private int getMaxBadDivisionLimit() {
+    private int getMaxBadDivisionLimit(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return new PositiveInteger(Integer.parseInt(thresholds.get("maxBadDivisionLimit"))).intValue();
+
         return ((PositiveInteger) antiPattern.getThresholds().get("maxBadDivisionLimit").getValue()).intValue();
     }
 
@@ -72 +79 @@
      * @return detection result
      */
     @Override
-    public QueryResultItem analyze(Project project, DatabaseConnection databaseConnection) {
+    public QueryResultItem analyze(Project project, DatabaseConnection databaseConnection, Map<String, String> thresholds) {
 
         List<ResultDetail> resultDetails = new ArrayList<>();
         List<Double> divisionsResults = new ArrayList<>();
@@ -88 +95 @@
                 }
                 divisionsResults.add(resultDivision);
                 // if is one division is out of range set boolean to false
-                if (resultDivision > getMaxDivisionRange()) {
+                if (resultDivision > getMaxDivisionRange(thresholds)) {
                     isAllInRange = false;
                 }
             }
@@ -102 +109 @@
 
         int counterOverEstimated = 0;
         for (Double divisionResult : divisionsResults) {
-            if (divisionResult > getMaxDivisionRange()) {
+            if (divisionResult > getMaxDivisionRange(thresholds)) {
                 counterOverEstimated++;
             } else {
                 counterOverEstimated = 0;
             }
 
-            if (counterOverEstimated > getMaxBadDivisionLimit()) {
+            if (counterOverEstimated > getMaxBadDivisionLimit(thresholds)) {
                 resultDetails.add(new ResultDetail("Conclusion",
-                        getMaxBadDivisionLimit() + " or more consecutive iterations has a bad trend in estimates"));
+                        getMaxBadDivisionLimit(thresholds) + " or more consecutive iterations has a bad trend in estimates"));
                 return new QueryResultItem(this.antiPattern, true, resultDetails);
             }
 

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/detecting/detectors/RoadToNowhereDetectorImpl.java

@@ -2 +2 @@
 
 import cz.zcu.fav.kiv.antipatterndetectionapp.detecting.DatabaseConnection;
 import cz.zcu.fav.kiv.antipatterndetectionapp.model.*;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.types.Percentage;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.types.PositiveFloat;
 import cz.zcu.fav.kiv.antipatterndetectionapp.model.types.PositiveInteger;
 import cz.zcu.fav.kiv.antipatterndetectionapp.service.AntiPatternService;
 import cz.zcu.fav.kiv.antipatterndetectionapp.service.AntiPatternServiceImpl;
@@ -14 +16 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
 
 public class RoadToNowhereDetectorImpl implements AntiPatternDetector {
 
@@ -34 +37 @@
     // sql queries loaded from sql file
     private List<String> sqlQueries;
 
-    private int getMinNumberOfWikiPagesWithProjectPlan() {
+    private int getMinNumberOfWikiPagesWithProjectPlan(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return new PositiveInteger(Integer.parseInt(thresholds.get("minNumberOfWikiPagesWithProjectPlan"))).intValue();
+
         return ((PositiveInteger) antiPattern.getThresholds().get("minNumberOfWikiPagesWithProjectPlan").getValue()).intValue();
     }
 
-    private int getMinNumberOfActivitiesWithProjectPlan() {
+    private int getMinNumberOfActivitiesWithProjectPlan(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return new PositiveInteger(Integer.parseInt(thresholds.get("minNumberOfActivitiesWithProjectPlan"))).intValue();
+
         return ((PositiveInteger) antiPattern.getThresholds().get("minNumberOfActivitiesWithProjectPlan").getValue()).intValue();
     }
 
-    private List<String> getSearchSubstringsWithProjectPlan() {
+    private List<String> getSearchSubstringsWithProjectPlan(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return Arrays.asList(thresholds.get("searchSubstringsWithProjectPlan").split("\\|\\|"));
+
         return Arrays.asList(((String) antiPattern.getThresholds().get("searchSubstringsWithProjectPlan").getValue()).split("\\|\\|"));
     }
 
@@ -82 +94 @@
      * @return detection result
      */
     @Override
-    public QueryResultItem analyze(Project project, DatabaseConnection databaseConnection) {
+    public QueryResultItem analyze(Project project, DatabaseConnection databaseConnection, Map<String, String> thresholds) {
 
         /* Init values */
         List<ResultDetail> resultDetails = new ArrayList<>();
@@ -91 +103 @@
 
         try {
             ResultSet rs = databaseConnection.executeQueries(project,
-                    Utils.fillQueryWithSearchSubstrings(this.sqlQueries, getSearchSubstringsWithProjectPlan()));
+                    Utils.fillQueryWithSearchSubstrings(this.sqlQueries, getSearchSubstringsWithProjectPlan(thresholds)));
             if (rs != null) {
                 while (rs.next()) {
                     numberOfIssuesForProjectPlan = rs.getInt("numberOfActivitiesWithSubstrings");
@@ -108 +120 @@
         resultDetails.add(new ResultDetail("Number of issues for creating project plan", String.valueOf(numberOfIssuesForProjectPlan)));
         resultDetails.add(new ResultDetail("Number of wiki pages for creating project plan", String.valueOf(numberOfWikiPagesForProjectPlan)));
 
-        if (numberOfIssuesForProjectPlan >= getMinNumberOfActivitiesWithProjectPlan() || numberOfWikiPagesForProjectPlan >= getMinNumberOfWikiPagesWithProjectPlan()) {
+        if (numberOfIssuesForProjectPlan >= getMinNumberOfActivitiesWithProjectPlan(thresholds) || numberOfWikiPagesForProjectPlan >= getMinNumberOfWikiPagesWithProjectPlan(thresholds)) {
             resultDetails.add(new ResultDetail("Conclusion", "Found some activities or wiki pages for project plan in first two iterations"));
             return new QueryResultItem(this.antiPattern, false, resultDetails);
         } else {

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/detecting/detectors/SpecifyNothingDetectorImpl.java

@@ -14 +14 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
 
 public class SpecifyNothingDetectorImpl implements AntiPatternDetector {
 
@@ -33 +34 @@
     // sql queries loaded from sql file
     private List<String> sqlQueries;
 
-    private int getMinNumberOfWikiPagesWithSpecification() {
+    private int getMinNumberOfWikiPagesWithSpecification(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return new PositiveInteger(Integer.parseInt(thresholds.get("minNumberOfWikiPagesWithSpecification"))).intValue();
+
         return ((PositiveInteger) antiPattern.getThresholds().get("minNumberOfWikiPagesWithSpecification").getValue()).intValue();
     }
 
-    private int getMinNumberOfActivitiesWithSpecification() {
+    private int getMinNumberOfActivitiesWithSpecification(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return new PositiveInteger(Integer.parseInt(thresholds.get("minNumberOfActivitiesWithSpecification"))).intValue();
+
         return ((PositiveInteger) antiPattern.getThresholds().get("minNumberOfActivitiesWithSpecification").getValue()).intValue();
     }
 
-    private int getMinAvgLengthOfActivityDescription() {
+    private int getMinAvgLengthOfActivityDescription(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return new PositiveInteger(Integer.parseInt(thresholds.get("minAvgLengthOfActivityDescription"))).intValue();
+
         return ((PositiveInteger) antiPattern.getThresholds().get("minAvgLengthOfActivityDescription").getValue()).intValue();
     }
 
-    private List<String> getSearchSubstringsWithProjectSpecification() {
+    private List<String> getSearchSubstringsWithProjectSpecification(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return Arrays.asList(thresholds.get("searchSubstringsWithProjectSpecification").split("\\|\\|"));
+
         return Arrays.asList(((String) antiPattern.getThresholds().get("searchSubstringsWithProjectSpecification").getValue()).split("\\|\\|"));
     }
 
@@ -87 +100 @@
      * @return detection result
      */
     @Override
-    public QueryResultItem analyze(Project project, DatabaseConnection databaseConnection) {
+    public QueryResultItem analyze(Project project, DatabaseConnection databaseConnection, Map<String, String> thresholds) {
 
         /* Init values */
         List<ResultDetail> resultDetails = new ArrayList<>();
@@ -97 +110 @@
 
         try {
             ResultSet rs = databaseConnection.executeQueries(project,
-                    Utils.fillQueryWithSearchSubstrings(this.sqlQueries, getSearchSubstringsWithProjectSpecification()));
+                    Utils.fillQueryWithSearchSubstrings(this.sqlQueries, getSearchSubstringsWithProjectSpecification(thresholds)));
             if (rs != null) {
                 while (rs.next()) {
                     numberOfWikiPages = rs.getInt("numberOfWikiPagesWithSubstrings");
@@ -115 +128 @@
         resultDetails.add(new ResultDetail("Number of activities for specification", String.valueOf(numberOfActivitiesForSpecification)));
         resultDetails.add(new ResultDetail("Number of wiki pages for specification", String.valueOf(numberOfWikiPages)));
 
-        if (numberOfActivitiesForSpecification >= getMinNumberOfActivitiesWithSpecification() ||
-                numberOfWikiPages >= getMinNumberOfWikiPagesWithSpecification()) {
+        if (numberOfActivitiesForSpecification >= getMinNumberOfActivitiesWithSpecification(thresholds) ||
+                numberOfWikiPages >= getMinNumberOfWikiPagesWithSpecification(thresholds)) {
             resultDetails.add(new ResultDetail("Conclusion", "Found activities or wiki pages that represents creation of specification"));
             return new QueryResultItem(this.antiPattern, false, resultDetails);
         } else {
-            if (averageLengthOfIssueDescription > getMinAvgLengthOfActivityDescription()) {
+            if (averageLengthOfIssueDescription > getMinAvgLengthOfActivityDescription(thresholds)) {
                 resultDetails.add(new ResultDetail("Conclusion", "Average length of activity description is grater then minimum"));
                 return new QueryResultItem(this.antiPattern, false, resultDetails);
             } else {

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/detecting/detectors/TooLongSprintDetectorImpl.java

@@ -53 +53 @@
         this.sqlQueries = queries;
     }
 
-    private Integer getMaxIterationLength() {
+    private Integer getMaxIterationLength(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return new PositiveInteger(Integer.parseInt(thresholds.get("maxIterationLength"))).intValue();
+
         return ((PositiveInteger) this.antiPattern.getThresholds().get("maxIterationLength").getValue()).intValue();
     }
 
-    private Integer getMaxNumberOfTooLongIterations() {
+    private Integer getMaxNumberOfTooLongIterations(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return new PositiveInteger(Integer.parseInt(thresholds.get("maxNumberOfTooLongIterations"))).intValue();
+
         return ((PositiveInteger) this.antiPattern.getThresholds().get("maxNumberOfTooLongIterations").getValue()).intValue();
     }
 
@@ -74 +80 @@
      * @return detection result
      */
     @Override
-    public QueryResultItem analyze(Project project, DatabaseConnection databaseConnection) {
+    public QueryResultItem analyze(Project project, DatabaseConnection databaseConnection, Map<String, String> thresholds) {
 
         // get configuration
-        int maxIterationLength = getMaxIterationLength();
-        int maxNumberOfTooLongIterations = getMaxNumberOfTooLongIterations();
+        int maxIterationLength = getMaxIterationLength(thresholds);
+        int maxNumberOfTooLongIterations = getMaxNumberOfTooLongIterations(thresholds);
 
         // auxiliary variables
         int numberOfLongIterations = 0;
@@ -106 +112 @@
             resultDetails.add(new ResultDetail("Conclusion", "All iterations in limit"));
         }
 
-        LOGGER.info(this.antiPattern.getPrintName());
-        LOGGER.info(resultDetails.toString());
-
         return new QueryResultItem(this.antiPattern, numberOfLongIterations > maxNumberOfTooLongIterations, resultDetails);
     }
 }

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/detecting/detectors/VaryingSprintLengthDetectorImpl.java

@@ -13 +13 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
 
 public class VaryingSprintLengthDetectorImpl implements AntiPatternDetector {
 
@@ -31 +32 @@
     // sql queries loaded from sql file
     private List<String> sqlQueries;
 
-    private Integer getMaxDaysDifference() {
+    private Integer getMaxDaysDifference(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return new PositiveInteger(Integer.parseInt(thresholds.get("maxDaysDifference"))).intValue();
+
         return ((PositiveInteger) this.antiPattern.getThresholds().get("maxDaysDifference").getValue()).intValue();
     }
 
-    private Integer getMaxIterationChanged() {
+    private Integer getMaxIterationChanged(Map<String, String> thresholds) {
+        if(thresholds != null)
+            return new PositiveInteger(Integer.parseInt(thresholds.get("maxIterationChanged"))).intValue();
+
         return ((PositiveInteger) this.antiPattern.getThresholds().get("maxIterationChanged").getValue()).intValue();
     }
 
@@ -78 +85 @@
      * @return detection result
      */
     @Override
-    public QueryResultItem analyze(Project project, DatabaseConnection databaseConnection) {
+    public QueryResultItem analyze(Project project, DatabaseConnection databaseConnection, Map<String, String> thresholds) {
 
         // init values
         List<ResultDetail> resultDetails = new ArrayList<>();
@@ -100 +107 @@
                         secondIterationLength = iterationLength;
                     }
 
-                    if (Math.abs(firstIterationLength - secondIterationLength) >= getMaxDaysDifference()) {
+                    if (Math.abs(firstIterationLength - secondIterationLength) >= getMaxDaysDifference(thresholds)) {
                         iterationLengthChanged = iterationLengthChanged + 1;
                     }
                     firstIterationLength = secondIterationLength;
@@ -113 +120 @@
             return new QueryResultItem(this.antiPattern, true, resultDetails);
         }
 
-        resultDetails.add(new ResultDetail("Maximum iteration length change", String.valueOf(getMaxIterationChanged())));
+        resultDetails.add(new ResultDetail("Maximum iteration length change", String.valueOf(getMaxIterationChanged(thresholds))));
         resultDetails.add(new ResultDetail("Count of iterations", String.valueOf(numberOfIterations)));
         resultDetails.add(new ResultDetail("Iteration length changed", String.valueOf(iterationLengthChanged)));
 
 
-        if (iterationLengthChanged > getMaxIterationChanged()) {
+        if (iterationLengthChanged > getMaxIterationChanged(thresholds)) {
             resultDetails.add(new ResultDetail("Conclusion", "Iteration length changed significantly too often"));
         } else {
             resultDetails.add(new ResultDetail("Conclusion", "Varying iteration length is all right"));
         }
 
-        LOGGER.info(this.antiPattern.getPrintName());
-        LOGGER.info(resultDetails.toString());
-
-        return new QueryResultItem(this.antiPattern, (iterationLengthChanged > getMaxIterationChanged()), resultDetails);
+        return new QueryResultItem(this.antiPattern, (iterationLengthChanged > getMaxIterationChanged(thresholds)), resultDetails);
     }
 }

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/service/ConfigurationService.java

@@ -1 +1 @@
 package cz.zcu.fav.kiv.antipatterndetectionapp.service;
 
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 public interface ConfigurationService {
 
@@ -8 +10 @@
 
     List<String> getDefaultConfigurationNames();
 
-
+    Map<String, Map<String, String>> getConfigurationByName(String configurationName);
 }

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/service/ConfigurationServiceImpl.java

@@ -6 +6 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 @Service
 public class ConfigurationServiceImpl implements ConfigurationService {
@@ -17 +18 @@
     public List<String> getAllConfigurationNames() {
         List<String> configList = new ArrayList<String>();
 
-        // get all configurations
+        // insert default configuration
+        configList.add("Default");
+
+        // get all external configurations
         for (String key : configurationRepository.allConfigurations.keySet() ) {
             configList.add(key);
         }
@@ -35 +39 @@
         return configList;
     }
 
+    @Override
+    public Map<String, Map<String, String>> getConfigurationByName(String configurationName) {
+        return configurationRepository.allConfigurations.get(configurationName);
+    }
 }

src/main/webapp/configurations/Default.json

@@ -1 @@
-{
-    "configuration": [
-        {
-            "antiPattern": "TooLongSprint",
-            "thresholds": [
-                {
-                    "thresholdName": "maxIterationLength",
-                    "value": "21"
-                },
-                {
-                    "thresholdName": "maxNumberOfTooLongIterations",
-                    "value": "0"
-                }
-            ]
-        },
-        {
-            "antiPattern": "VaryingSprintLength",
-            "thresholds": [
-                {
-                    "thresholdName": "maxDaysDifference",
-                    "value": "7"
-                },
-                {
-                    "thresholdName": "maxIterationChanged",
-                    "value": "1"
-                }
-            ]
-        },
-        {
-            "antiPattern": "BusinessAsUsual",
-            "thresholds": [
-                {
-                    "thresholdName": "divisionOfIterationsWithRetrospective",
-                    "value": "66.66f"
-                },
-                {
-                    "thresholdName": "searchSubstringsWithRetrospective",
-                    "value": "%retr%||%revi%||%week%scrum%"
-                }
-            ]
-        },
-        {
-            "antiPattern": "SpecifyNothing",
-            "thresholds": [
-                {
-                    "thresholdName": "minNumberOfWikiPagesWithSpecification",
-                    "value": "1"
-                },
-                {
-                    "thresholdName": "minNumberOfActivitiesWithSpecification",
-                    "value": "1"
-                },
-                {
-                    "thresholdName": "minAvgLengthOfActivityDescription",
-                    "value": "150"
-                },
-                {
-                    "thresholdName": "searchSubstringsWithProjectSpecification",
-                    "value": "%dsp%||%specifikace%||%specification%||%vize%proj%||%vize%produ%"
-                }
-            ]
-        },
-        {
-            "antiPattern": "RoadToNowhere",
-            "thresholds": [
-                {
-                    "thresholdName": "minNumberOfWikiPagesWithProjectPlan",
-                    "value": "1"
-                },
-                {
-                    "thresholdName": "minNumberOfActivitiesWithProjectPlan",
-                    "value": "1"
-                },
-                {
-                    "thresholdName": "searchSubstringsWithProjectPlan",
-                    "value": "%plán projektu%||%project plan%||%plan project%||%projektový plán%"
-                }
-            ]
-        },
-        {
-            "antiPattern": "LongOrNonExistentFeedbackLoops",
-            "thresholds": [
-                {
-                    "thresholdName": "divisionOfIterationsWithFeedbackLoop",
-                    "value": "50.00f"
-                },
-                {
-                    "thresholdName": "maxGapBetweenFeedbackLoopRate",
-                    "value": "2f"
-                },
-                {
-                    "thresholdName": "searchSubstringsWithFeedbackLoop",
-                    "value": "%schůz%zákazník%||%předvedení%zákazník%||%zákazn%demo%||%schůz%zadavat%||%inform%schůz%||%zákazn%||%zadavatel%"
-                }
-            ]
-        },
-        {
-            "antiPattern": "NinetyNinetyRule",
-            "thresholds": [
-                {
-                    "thresholdName": "maxDivisionRange",
-                    "value": "1.25f"
-                },
-                {
-                    "thresholdName": "maxBadDivisionLimit",
-                    "value": "2"
-                }
-            ]
-        }
-    ]
-}

src/main/webapp/configurations/MyConfig.json

@@ +1 @@
+{
+    "configuration": [
+        {
+            "antiPattern": "TooLongSprint",
+            "thresholds": [
+                {
+                    "thresholdName": "maxIterationLength",
+                    "value": "21"
+                },
+                {
+                    "thresholdName": "maxNumberOfTooLongIterations",
+                    "value": "0"
+                }
+            ]
+        },
+        {
+            "antiPattern": "VaryingSprintLength",
+            "thresholds": [
+                {
+                    "thresholdName": "maxDaysDifference",
+                    "value": "7"
+                },
+                {
+                    "thresholdName": "maxIterationChanged",
+                    "value": "1"
+                }
+            ]
+        },
+        {
+            "antiPattern": "BusinessAsUsual",
+            "thresholds": [
+                {
+                    "thresholdName": "divisionOfIterationsWithRetrospective",
+                    "value": "66.66f"
+                },
+                {
+                    "thresholdName": "searchSubstringsWithRetrospective",
+                    "value": "%retr%||%revi%||%week%scrum%"
+                }
+            ]
+        },
+        {
+            "antiPattern": "SpecifyNothing",
+            "thresholds": [
+                {
+                    "thresholdName": "minNumberOfWikiPagesWithSpecification",
+                    "value": "1"
+                },
+                {
+                    "thresholdName": "minNumberOfActivitiesWithSpecification",
+                    "value": "1"
+                },
+                {
+                    "thresholdName": "minAvgLengthOfActivityDescription",
+                    "value": "150"
+                },
+                {
+                    "thresholdName": "searchSubstringsWithProjectSpecification",
+                    "value": "%dsp%||%specifikace%||%specification%||%vize%proj%||%vize%produ%"
+                }
+            ]
+        },
+        {
+            "antiPattern": "RoadToNowhere",
+            "thresholds": [
+                {
+                    "thresholdName": "minNumberOfWikiPagesWithProjectPlan",
+                    "value": "1"
+                },
+                {
+                    "thresholdName": "minNumberOfActivitiesWithProjectPlan",
+                    "value": "1"
+                },
+                {
+                    "thresholdName": "searchSubstringsWithProjectPlan",
+                    "value": "%plán projektu%||%project plan%||%plan project%||%projektový plán%"
+                }
+            ]
+        },
+        {
+            "antiPattern": "LongOrNonExistentFeedbackLoops",
+            "thresholds": [
+                {
+                    "thresholdName": "divisionOfIterationsWithFeedbackLoop",
+                    "value": "50.00f"
+                },
+                {
+                    "thresholdName": "maxGapBetweenFeedbackLoopRate",
+                    "value": "2f"
+                },
+                {
+                    "thresholdName": "searchSubstringsWithFeedbackLoop",
+                    "value": "%schůz%zákazník%||%předvedení%zákazník%||%zákazn%demo%||%schůz%zadavat%||%inform%schůz%||%zákazn%||%zadavatel%"
+                }
+            ]
+        },
+        {
+            "antiPattern": "NinetyNinetyRule",
+            "thresholds": [
+                {
+                    "thresholdName": "maxDivisionRange",
+                    "value": "1.25f"
+                },
+                {
+                    "thresholdName": "maxBadDivisionLimit",
+                    "value": "2"
+                }
+            ]
+        }
+    ]
+}