Revize e9a96fd8

https://kivprogrammers.atlassian.net/browse/TSP2-23 soubory Bp Adama Šmucra do SPADE

pom.xml

@@ -77 +77 @@
 	</dependencyManagement>
 
 	<dependencies>
-
+		<dependency>
+			<groupId>org.projectlombok</groupId>
+			<artifactId>lombok</artifactId>
+			<version>1.18.30</version>
+			<scope>provided</scope>
+		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter</artifactId>

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

@@ -3 +3 @@
 
 import cz.zcu.fav.kiv.antipatterndetectionapp.detecting.AntiPatternManager;
 import cz.zcu.fav.kiv.antipatterndetectionapp.model.AntiPattern;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.Project;
 import cz.zcu.fav.kiv.antipatterndetectionapp.model.Query;
 import cz.zcu.fav.kiv.antipatterndetectionapp.model.QueryResult;
 import cz.zcu.fav.kiv.antipatterndetectionapp.service.AntiPatternService;
 import cz.zcu.fav.kiv.antipatterndetectionapp.service.ConfigurationService;
 import cz.zcu.fav.kiv.antipatterndetectionapp.service.ProjectService;
 import cz.zcu.fav.kiv.antipatterndetectionapp.service.UserAccountService;
+import cz.zcu.fav.kiv.antipatterndetectionapp.v2.model.ProjectDto;
+import cz.zcu.fav.kiv.antipatterndetectionapp.v2.utils.converters.ClassToDto;
+import cz.zcu.fav.kiv.antipatterndetectionapp.v2.utils.converters.ProjectToDto;
 import org.jsoup.Jsoup;
 import org.jsoup.safety.Safelist;
 import org.slf4j.Logger;
@@ -55 +59 @@
     @Autowired
     private ConfigurationService configurationService;
 
+    private final ClassToDto<Project, ProjectDto> classToDto = new ProjectToDto();
+
     @GetMapping("/")
     public String mainPage(Model model) {
-        model.addAttribute("query", new Query(projectService.getAllProjects(), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
+        model.addAttribute("query", new Query(classToDto.convert(projectService.getAllProjects()), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
         return "main-page";
     }
 
@@ -71 +77 @@
      */
     @GetMapping("/detect")
     public String index(Model model) {
-        model.addAttribute("query", new Query(projectService.getAllProjects(), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
+        model.addAttribute("query", new Query(classToDto.convert(projectService.getAllProjects()), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
         LOGGER.info("@GetMapping(\"/\") - Accessing main page");
         return "index";
     }
@@ -85 +91 @@
      */
     @GetMapping("/projects/{id}")
     public String getProjectById(@PathVariable Long id, Model model) {
-        model.addAttribute("query", new Query(projectService.getAllProjects(), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
+        model.addAttribute("query", new Query(classToDto.convert(projectService.getAllProjects()), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
         model.addAttribute("project", projectService.getProjectById(id));
         LOGGER.info("@GetMapping(\"projects/" + id + ")");
         return "project";
@@ -97 +103 @@
      */
     @GetMapping("/anti-patterns")
     public @ResponseBody List<AntiPattern> getAllAntiPatterns(Model model) {
-        model.addAttribute("query", new Query(projectService.getAllProjects(), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
+        model.addAttribute("query", new Query(classToDto.convert(projectService.getAllProjects()), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
         LOGGER.info("GetMapping(\"/anti-patterns\") and obtaining all APs.");
         return antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns());
     }
@@ -112 +118 @@
     @GetMapping("/anti-patterns/{id}")
     public String getAntiPatternById(@PathVariable Long id, Model model, HttpSession session) {
         String currentConfigurationName = configurationGetFromSession(session);
-        model.addAttribute("query", new Query(projectService.getAllProjects(), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
+        model.addAttribute("query", new Query(classToDto.convert(projectService.getAllProjects()), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
         model.addAttribute("antiPattern", antiPatternService.getAntiPatternById(id).getAntiPatternModel());
         model.addAttribute("description", antiPatternService.getDescriptionFromCatalogue(id));
         model.addAttribute("operationalizationText", antiPatternService.getOperationalizationText(antiPatternService.getAntiPatternById(id).getAntiPatternModel().getName()));
@@ -140 +146 @@
 
         if (currentConfigurationName == null) {
             model.addAttribute("errorMessage", "No configuration was found!");
-            model.addAttribute("query", new Query(projectService.getAllProjects(), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
+            model.addAttribute("query", new Query(classToDto.convert(projectService.getAllProjects()), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
             return "index";
         }
 
         if (selectedProjects == null) {
             model.addAttribute("errorMessage", "No project selected." +
                     " Select at least one project.");
-            model.addAttribute("query", new Query(projectService.getAllProjects(), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
+            model.addAttribute("query", new Query(classToDto.convert(projectService.getAllProjects()), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
             LOGGER.warn("@PostMapping(\"/analyze\") - Processing requirements for analyzing selected projects and AP with an error. " +
                     "selectedProjects are null!");
             return "index";
@@ -156 +162 @@
         if (selectedAntiPatterns == null) {
             model.addAttribute("errorMessage", "No anti-pattern selected." +
                     " Select at least one anti-pattern.");
-            model.addAttribute("query", new Query(projectService.getAllProjects(), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
+            model.addAttribute("query", new Query(classToDto.convert(projectService.getAllProjects()), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
             LOGGER.warn("@PostMapping(\"/analyze\") - Processing requirements for analyzing selected projects and AP with an error. " +
                     "selectedAntiPatterns are null!");
             return "index";
@@ -170 +176 @@
         antiPatternService.saveResults(results);
         antiPatternService.setConfigurationChanged(false);
 
-        model.addAttribute("query", new Query(projectService.getAllProjects(), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
+        model.addAttribute("query", new Query(classToDto.convert(projectService.getAllProjects()), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
         model.addAttribute("queryResults", results);
         model.addAttribute("recalculationTime", DateTimeFormatter.ofPattern("HH:mm:ss").format(LocalTime.now()));
 
@@ -192 +198 @@
         }
         antiPatternService.setConfigurationChanged(false);
 
-        model.addAttribute("query", new Query(projectService.getAllProjects(), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
+        model.addAttribute("query", new Query(classToDto.convert(projectService.getAllProjects()), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
         model.addAttribute("queryResults", antiPatternService.getResults());
         model.addAttribute("recalculationTime", DateTimeFormatter.ofPattern("HH:mm:ss").format(LocalTime.now()));
 
@@ -207 +213 @@
      */
     @GetMapping("/about")
     public String about(Model model) {
-        model.addAttribute("query", new Query(projectService.getAllProjects(), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
+        model.addAttribute("query", new Query(classToDto.convert(projectService.getAllProjects()), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
         LOGGER.info("@GetMapping(\"/about\") - Accessing about page");
         return "about";
     }
@@ -220 +226 @@
      */
     @GetMapping("/configuration")
     public String configuration(Model model, HttpSession session) {
-        model.addAttribute("query", new Query(projectService.getAllProjects(), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
+        model.addAttribute("query", new Query(classToDto.convert(projectService.getAllProjects()), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
         model.addAttribute("antiPatterns", antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns()));
 
         String currentConfigurationName = configurationGetFromSession(session);
@@ -245 +251 @@
 
         String currentConfigurationName = configurationGetFromSession(session);
 
-        Query query = new Query(projectService.getAllProjects(), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns()));
+        Query query = new Query(classToDto.convert(projectService.getAllProjects()), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns()));
 
         List<String> wrongParameters = configurationService.saveNewConfiguration(query.getAntiPatterns(), currentConfigurationName, antiPatternNames, thresholdNames, thresholdValues, true);
 
@@ -283 +289 @@
                                     @RequestParam(value = "configuration-save-as-input") String newConfigName,
                                     HttpSession session, RedirectAttributes redirectAttributes) {
 
-        Query query = new Query(projectService.getAllProjects(), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns()));
+        Query query = new Query(classToDto.convert(projectService.getAllProjects()), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns()));
         String currentConfigurationName = configurationGetFromSession(session);
 
         List<String> allConfigurationNames = configurationService.getAllConfigurationNames();
@@ -439 +445 @@
      */
     @GetMapping("/login")
     public String login(Model model) {
-        model.addAttribute("query", new Query(projectService.getAllProjects(), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
+        model.addAttribute("query", new Query(classToDto.convert(projectService.getAllProjects()), antiPatternService.antiPatternsToModel(antiPatternService.getAllAntiPatterns())));
         return "login";
     }
 

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/controller/management/EnumController.java

@@ +1 @@
+package cz.zcu.fav.kiv.antipatterndetectionapp.controller.management;
+
+import cz.zcu.fav.kiv.antipatterndetectionapp.Constants;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.Project;
+import cz.zcu.fav.kiv.antipatterndetectionapp.service.ProjectService;
+import cz.zcu.fav.kiv.antipatterndetectionapp.service.managment.enums.*;
+import cz.zcu.fav.kiv.antipatterndetectionapp.utils.Utils;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.management.FormObject;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.management.ProjectInstance;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.management.interfaces.Classification;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.management.interfaces.EnumType;
+import cz.zcu.fav.kiv.antipatterndetectionapp.service.managment.Service;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.util.Pair;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.servlet.mvc.support.RedirectAttributes;
+
+import javax.annotation.PostConstruct;
+import javax.servlet.http.HttpSession;
+import java.util.*;
+
+/**
+ * This class contains all endpoints of enums.html
+ */
+@Controller
+public class EnumController {
+
+    private final Logger LOGGER = LoggerFactory.getLogger(EnumController.class);
+
+    @Autowired
+    private PriorityService priorityService;
+
+    @Autowired
+    private SeverityService severityService;
+
+    @Autowired
+    private RelationService  relationService;
+
+    @Autowired
+    private ResolutionService resolutionService;
+
+    @Autowired
+    private RoleService roleService;
+
+    @Autowired
+    private StatusService statusService;
+
+    @Autowired
+    private WuTypeService wuTypeService;
+
+    @Autowired
+    private PriorityClassificationService priorityClassificationService;
+
+    @Autowired
+    private SeverityClassificationService severityClassificationService;
+
+    @Autowired
+    private StatusClassificationService statusClassificationService;
+
+    @Autowired
+    private RoleClassificationService roleClassificationService;
+
+    @Autowired
+    private ResolutionClassificationService resolutionClassificationService;
+
+    @Autowired
+    private WuTypeClassificationService wuTypeClassificationService;
+
+    @Autowired
+    private RelationClassificationService relationClassificationService;
+
+    @Autowired
+    private ProjectService projectService;
+
+    private Map<String, Pair<Service, EnumService>> services;
+
+    /**
+     * Method initializing map of enum
+     * services and their classifications
+     */
+    @PostConstruct
+    private void initializeMap() {
+        services = Map.ofEntries(
+                Map.entry("Priority", Pair.of(priorityClassificationService, priorityService)),
+                Map.entry("Severity", Pair.of(severityClassificationService, severityService)),
+                Map.entry("Status", Pair.of(statusClassificationService, statusService)),
+                Map.entry("Role", Pair.of(roleClassificationService, roleService)),
+                Map.entry("Resolution", Pair.of(resolutionClassificationService, resolutionService)),
+                Map.entry("WuType", Pair.of(wuTypeClassificationService, wuTypeService)),
+                Map.entry("Relation", Pair.of(relationClassificationService, relationService))
+        );
+    }
+
+    /**
+     * Method for showing enums in tabs
+     * @param model         Object for passing data to the UI
+     * @param project       Selected project for showing enums
+     * @param redirectAttrs Attributes for redirection
+     * @param session       Session with attributes
+     * @return              HTML template
+     */
+    @GetMapping("/management/enums")
+    public String changeTab(Model model,
+                            @RequestParam(value = "selectedProject", required = false) Long project,
+                            RedirectAttributes redirectAttrs,
+                            HttpSession session) {
+
+        // First open in session
+        if(project == null && session.getAttribute("project") == null) {
+            model.addAttribute("projects", projectService.getAllProjects());
+            LOGGER.info("@GetMapping(\"/management/enums\") - Accessing page");
+            return "management/enums";
+        }
+
+        // Project selected
+        if(project != null) {
+            session.setAttribute("project", project);
+            Utils.sessionRecreate(session);
+        }
+
+        project = (long) session.getAttribute("project");
+
+        Project foundedProject = projectService.getProjectById(project);
+        if(foundedProject == null) {
+            if(!Objects.equals(project, Constants.DEFAULT_ID)) {
+                redirectAttrs.addFlashAttribute("errorMessage", "Project not found");
+                LOGGER.info("@GetMapping(\"/management/enums\")- Project not found");
+            } else {
+                LOGGER.info("@GetMapping(\"/management/enums\") - Accessing page");
+            }
+            model.addAttribute("projects", projectService.getAllProjects());
+            return "management/enums";
+        }
+
+        // For each project instance of project, get all enums
+        for(Map.Entry<String, Pair<Service, EnumService>> entry : services.entrySet()) {
+
+            Set<EnumType> enums = new HashSet<>(); // Enums of current enum type
+            Service service = entry.getValue().getFirst(); // Service for current enum type
+
+            // For each project instance, get all enums for current enum type
+            for(ProjectInstance projectInstance : foundedProject.getProjectInstances()) {
+                Set<EnumType> enumsByName = (Set<EnumType>) projectInstance.getEnumsByName(entry.getKey());
+                if(enumsByName != null) {
+                    enums.addAll(enumsByName);
+                }
+            }
+
+            // Create classification pairs with enums
+            List<Pair<Classification, List<EnumType>>> pairs = createClassPairs(service, enums);
+
+            //Calculate rowspan for superclasses
+            List<Integer> superClassSpan = calculateSpan(pairs);
+
+            model.addAttribute(entry.getKey(), pairs);
+            model.addAttribute(entry.getKey() + "All", service.getAllClasses());
+            model.addAttribute(entry.getKey() + "Super", superClassSpan);
+        }
+
+        model.addAttribute("projects", projectService.getAllProjects());
+        model.addAttribute("result", new FormObject());
+        return "management/enums";
+    }
+
+    /**
+     * Method for changing enum class for selected enums
+     * @param model         Object for passing data to the UI
+     * @param selectedEnums Selected enums for change of their class
+     * @param selectedClass Selected class for enums
+     * @param enumName      Name of the current selected tab
+     * @param redirectAttrs Attributes for redirection
+     * @return              Html template
+     */
+    @PostMapping(value = "/changeEnums")
+    public String changeEnums(Model model,
+                              @RequestParam(value = "selectedEnums", required = false) List<Long> selectedEnums,
+                              @RequestParam(value = "selectedClass", required = false) Long selectedClass,
+                              @RequestParam(value = "enumName", required = false) String enumName,
+                              RedirectAttributes redirectAttrs) {
+
+        if(selectedEnums == null || selectedEnums.isEmpty()) {
+            redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Nothing was selected");
+            LOGGER.info("@PostMapping(\"/management/enums\") - Nothing was selected");
+            return "redirect:/management/enums";
+        }
+
+        for(Long id : selectedEnums) {
+            Pair<Service, EnumService> pair = services.get(enumName);
+            if(pair != null) {
+                Service service = pair.getFirst();
+                EnumService enumService = pair.getSecond();
+
+                EnumType enumType = enumService.getEnumById(id);
+                enumType.setClassId(service.getClassById(selectedClass));
+                enumService.saveEnum(enumType);
+            }
+        }
+
+        redirectAttrs.addFlashAttribute("successMessage", "All selected enums (" + selectedEnums.size() + ") were successfully assigned");
+        redirectAttrs.addFlashAttribute("activeTab", enumName);
+        return "redirect:/management/enums";
+    }
+
+    /**
+     * Method creating pairs with enum type
+     * classification and list of relevant enums
+     * @param service   Enum service
+     * @param enums     Set of enums in specific project
+     * @return          List of pairs with enum class and relevant enums
+     */
+    private List<Pair<Classification, List<EnumType>>> createClassPairs(Service service, Set<EnumType> enums) {
+
+        List<Pair<Classification, List<EnumType>>> pairs = new ArrayList<>(); // List with enum types classes and their enums
+        for(Classification enumClass : service.getAllClasses()) {
+            Set<EnumType> enumSet = new HashSet<>(); // For each enum classification create new list for enums
+
+            //If enum class is equal to current class, add enum into list
+            for(EnumType e : enums) {
+                if(Objects.equals(e.getClassId().getId(), enumClass.getId())) {
+                    enumSet.add(e);
+                }
+            }
+
+            //If enum set has some enums in it, add pair to the final list
+            if(!enumSet.isEmpty()) {
+                List<EnumType> enumTypes = new ArrayList<>(enumSet);
+                Collections.sort(enumTypes, Comparator.comparing(EnumType::getName, String.CASE_INSENSITIVE_ORDER));
+                Pair<Classification, List<EnumType>> newPair = Pair.of(enumClass, enumTypes);
+                pairs.add(newPair);
+            }
+        }
+        return pairs;
+    }
+
+    /**
+     * Method calculating rowspan for superclasses
+     * @param pairs     Classification and list with enums
+     * @return          List with sizes of rowspan for each classification
+     */
+    private List<Integer> calculateSpan(List<Pair<Classification, List<EnumType>>> pairs) {
+        List<Integer> superClassSpan = new ArrayList<>(); // Superclass rowspan for current enum type
+        String preSuperClass = null;
+        int preListSize = 0;
+        int lastI = 0;
+        for(int i = 0; i < pairs.size(); i++) {
+            Pair<Classification, List<EnumType>> currentPair = pairs.get(i);
+            String currentSuperClass = currentPair.getFirst().getSuperClass();
+            int currentListSize = currentPair.getSecond().size();
+            if(preSuperClass == null || !currentSuperClass.contentEquals(preSuperClass)) {
+                superClassSpan.add(i, currentListSize);
+                lastI = i;
+            } else if(currentSuperClass.contentEquals(preSuperClass)) {
+                superClassSpan.set(lastI, preListSize + currentListSize);
+                superClassSpan.add(i, 0);
+                preListSize = preListSize + currentListSize;
+                continue;
+            }
+            preSuperClass = currentSuperClass;
+            preListSize = currentListSize;
+        }
+
+        return superClassSpan;
+    }
+}

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/controller/management/PersonController.java

@@ +1 @@
+package cz.zcu.fav.kiv.antipatterndetectionapp.controller.management;
+
+import cz.zcu.fav.kiv.antipatterndetectionapp.Constants;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.Project;
+import cz.zcu.fav.kiv.antipatterndetectionapp.service.ProjectService;
+import cz.zcu.fav.kiv.antipatterndetectionapp.utils.Utils;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.management.Person;
+import cz.zcu.fav.kiv.antipatterndetectionapp.service.managment.PersonService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.servlet.mvc.support.RedirectAttributes;
+
+import javax.servlet.http.HttpSession;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * This class contains all endpoints of person.html
+ */
+@Controller
+public class PersonController {
+
+    private final Logger LOGGER = LoggerFactory.getLogger(PersonController.class);
+
+    @Autowired
+    private PersonService personService;
+
+    @Autowired
+    private ProjectService projectService;
+
+    /**
+     * Method for showing people and their identities
+     * @param model         Object for passing data to the UI
+     * @param project       Selected project for showing people
+     * @param redirectAttrs Attributes for redirection
+     * @param session       Session with attributes
+     * @return              HTML template
+     */
+    //[JT] vyhodit http session
+    @GetMapping("/management/person")
+    public String people(Model model,
+                         @RequestParam(value = "selectedProject", required = false) Long project,
+                         RedirectAttributes redirectAttrs,
+                         HttpSession session) {
+
+        // [JT] tohle taky hodit pryc
+        //session pro nas neni platna - posilat v body requestu z klienta
+        if(project == null && session.getAttribute("project") == null) {
+            model.addAttribute("projects", projectService.getAllProjects());
+            LOGGER.info("@GetMapping(\"/management/person\") - Accessing page");
+            //[JT] prepsat do reactu
+            return "management/person";
+        }
+        //[JT] tohle pryc
+        // Project selected
+        if(project != null) {
+            session.setAttribute("project", project);
+            Utils.sessionRecreate(session);
+        }
+        //[JT] nerozumim
+        project = (long) session.getAttribute("project");
+
+        Project foundedProject = projectService.getProjectById(project);
+        //[JT] logika do service
+        if(foundedProject == null) {
+            if(!Objects.equals(project, Constants.DEFAULT_ID)) {
+                redirectAttrs.addFlashAttribute("errorMessage", "Project not found");
+                LOGGER.info("@GetMapping(\"/management/person\")- Project not found");
+            } else {
+                LOGGER.info("@GetMapping(\"/management/person\") - Accessing page");
+            }
+            //[JT] do reactu
+            model.addAttribute("projects", projectService.getAllProjects());
+            return "management/person";
+        }
+
+        List<Person> people = foundedProject.getPeople();
+        Collections.sort(people, Comparator.comparing(Person::getName, String.CASE_INSENSITIVE_ORDER));
+        //[JT] hodit do json response body
+        model.addAttribute("people", people);
+        model.addAttribute("projects", projectService.getAllProjects());
+        LOGGER.info("@GetMapping(\"/management/person\") - Accessing page");
+
+        return "management/person";
+    }
+
+    /**
+     * Method for merging people in same project
+     * @param model                 Object for passing data to the UI
+     * @param selectedPeople        People selected by user for merge
+     * @param personName            Name of the new person for merge
+     * @param redirectAttrs         Attributes for redirection
+     * @return                      HTML template
+     */
+    @PostMapping(value = "/changeIdentities")
+    public String mergeIdentities(Model model,
+                                  @RequestParam(value = "selectedBox", required = false) List<Person> selectedPeople,
+                                  @RequestParam(value = "personName", required = false) List<String> personName,
+                                  @RequestParam(value = "radioBtn", required = false) Integer radioBtn,
+                                  @RequestParam(value = "submitId", required = false) Long submitId,
+                                  RedirectAttributes redirectAttrs) {
+
+        // Nothing was selected
+        if(selectedPeople == null || selectedPeople.isEmpty()) {
+            redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Nothing was selected");
+            LOGGER.info("@PostMapping(\"/management/person\") - Nothing was selected or name was empty");
+
+        } else {
+
+            Person newPerson;
+            if(Objects.equals(submitId, Constants.DEFAULT_ID)) { // Creating new person
+
+                if(personName == null || personName.isEmpty() || radioBtn == null || personName.get(radioBtn).isEmpty()) { // Person name is not set
+                    redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Name of the new person is empty");
+                    LOGGER.info("@PostMapping(\"/management/person\") - Name of the new person is empty");
+                    return "redirect:/management/person";
+                }
+
+                Person createdPerson = new Person(personName.get(radioBtn), selectedPeople.get(0).getProject());
+                newPerson = personService.savePerson(createdPerson);
+
+            } else { // Merging to existing person
+                newPerson = personService.getPersonById(submitId);
+            }
+
+            if(newPerson != null) { // Person was found in database
+
+                if(selectedPeople.contains(newPerson)) {
+                    redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Person cannot be merged with itself");
+                    LOGGER.info("@PostMapping(\"/management/person\") - Person cannot be merged with itself");
+                    return "redirect:/management/person";
+                }
+
+                for(Person person : selectedPeople) { // Relation update for every selected person
+                    personService.updatePersonRelations(person.getId(), newPerson.getId());
+                    personService.deletePerson(person.getId());
+                }
+
+                redirectAttrs.addFlashAttribute("successMessage", "All identities of selected person were merged to person " + newPerson.getName());
+                LOGGER.info("@PostMapping(\"/management/person\") - Selected identities were merged to person with id " + submitId);
+
+            } else {
+                redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Selected person was not found");
+                LOGGER.info("@PostMapping(\"/management/person\") - Selected person with id " + submitId + " was not found");
+            }
+
+        }
+        return "redirect:/management/person";
+    }
+}

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/controller/management/ProjectController.java

@@ +1 @@
+package cz.zcu.fav.kiv.antipatterndetectionapp.controller.management;
+
+import cz.zcu.fav.kiv.antipatterndetectionapp.Constants;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.Project;
+import cz.zcu.fav.kiv.antipatterndetectionapp.service.ProjectService;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.management.types.Node;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.servlet.mvc.support.RedirectAttributes;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * This class contains all endpoints of projects.html
+ */
+@Controller
+public class ProjectController {
+
+    private final Logger LOGGER = LoggerFactory.getLogger(ProjectController.class);
+
+    @Autowired
+    private ProjectService projectService;
+
+    /**
+     * Method for visualization of project hierarchy
+     * @param model     Object for passing data to the UI
+     * @return          HTML template
+     */
+    @GetMapping("/management/projects")
+    public String projects(Model model) {
+        List<Node> parents = new ArrayList<>();
+        List<Project> parentProjects = projectService.getParentProjects();
+        for(Project parentProject : parentProjects) {
+            Node n = new Node();
+            n.project = parentProject;
+            n.children = new ArrayList<>();
+            parents.add(n);
+        }
+
+        for(Node n : parents) {
+            n.children = calculate(n.project);
+        }
+
+        model.addAttribute("parents", parents);
+        LOGGER.info("@GetMapping(\"/management/projects\") - Accessing page");
+        return "management/projects";
+    }
+
+    /**
+     * Method for changing superproject of selected projects
+     * @param model                 Object for passing data to the UI
+     * @param selectedProjects      Selected projects for changing their parent project
+     * @param selectedSuperProject  Selected project for being parent project
+     * @param projectName           Name of new created project that will take a place as parent project
+     * @param redirectAttrs         Redirect attributes
+     * @return                      HTML template
+     */
+    @PostMapping(value = "/superProjectChange")
+    public String projectChange(Model model,
+                                @RequestParam(value = "selectedBox", required = false) List<Project> selectedProjects,
+                                @RequestParam(value = "submitId", required = false) Long selectedSuperProject,
+                                @RequestParam(value = "projectName", required = false) String projectName,
+                                RedirectAttributes redirectAttrs) {
+
+        // Validity check
+        if(selectedProjects == null) {
+            redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Nothing was selected before submission");
+            LOGGER.warn("@PostMapping(\"/management/projects\") - Cannot proceed: Submission went wrong");
+
+        } else if(projectService.getProjectById(selectedSuperProject) == null && !Objects.equals(selectedSuperProject, Constants.DEFAULT_ID)) {
+            redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Superproject was not found");
+            LOGGER.warn("@PostMapping(\"/management/projects\") - Cannot proceed: Submission went wrong");
+
+        } else if(!Objects.equals(selectedSuperProject, Constants.DEFAULT_ID) && selectedProjects.contains(projectService.getProjectById(selectedSuperProject))) {
+            if(selectedProjects.size() == 1) {
+                selectedProjects.get(0).setSuperProject(null);
+                projectService.saveProject(selectedProjects.get(0));
+                redirectAttrs.addFlashAttribute("successMessage", "The project was set up as a parent project");
+            } else {
+                redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Project cannot be superproject for self");
+                LOGGER.warn("@PostMapping(\"/management/projects\") - Cannot proceed: Submission went wrong");
+            }
+
+        } else {
+            // User creating new superproject
+            if(Objects.equals(selectedSuperProject, Constants.DEFAULT_ID)) {
+                if(projectName == null || projectName.isEmpty()) {
+                    redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Name was not found");
+                    LOGGER.warn("@PostMapping(\"/management/projects\") - Cannot proceed: Submission went wrong");
+                } else {
+                    Project project = new Project(projectName);
+                    Project newProject = projectService.saveProject(project);
+                    for(Project subProject : selectedProjects) {
+                        subProject.setSuperProject(newProject);
+                        projectService.saveProject(subProject);
+                    }
+                    redirectAttrs.addFlashAttribute("successMessage", "Selected projects (" + selectedProjects.size() + ") were assign to " + newProject.getName());
+                }
+                return "redirect:/management/projects/";
+            }
+
+            // Check if there is no cycle
+            List<Project> childProjects = new ArrayList<>();
+            for(Project project : selectedProjects) {
+                addChildProject(project, childProjects);
+            }
+            if(childProjects.contains(projectService.getProjectById(selectedSuperProject))) {
+                redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Some selected projects cannot be assign - Selected superproject cannot be superior to its parent");
+                LOGGER.warn("@PostMapping(\"/management/projects\") - Cannot proceed: Submission went wrong");
+                return "redirect:/management/projects/";
+            }
+
+            // Changing superproject of all selected projects
+            for(Project project : selectedProjects) {
+                project.setSuperProject(projectService.getProjectById(selectedSuperProject));
+                projectService.saveProject(project);
+            }
+            redirectAttrs.addFlashAttribute("successMessage", "Selected projects (" + selectedProjects.size() + ") were assign to " + projectService.getProjectById(selectedSuperProject).getName());
+        }
+
+        return "redirect:/management/projects/";
+    }
+
+    /**
+     * Method for searching all subordinate projects of selected project
+     * @param project       Project for which the search will be done
+     * @param childProjects Collection of all subordinate projects
+     */
+    private void addChildProject(Project project, List<Project> childProjects) {
+        for(Project childProject : projectService.getSubordinateProjectsTo(project.getId())) {
+            childProjects.add(childProject);
+            addChildProject(childProject, childProjects);
+        }
+    }
+
+    /**
+     * Method creating the hierarchy of projects by recursion
+     * @param p Project for which the hierarchy will be generated
+     * @return  List of project's children with their hierarchy
+     */
+    private ArrayList<Node> calculate(Project p) {
+        ArrayList<Node> nodes = new ArrayList<>();
+        List<Project> projects = projectService.getSubordinateProjectsTo(p.getId());
+        for(Project project : projects) {
+            Node n = new Node();
+            n.project = project;
+            n.children = calculate(project);
+            nodes.add(n);
+        }
+        return nodes;
+    }
+}

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/controller/management/ReleaseController.java

@@ +1 @@
+package cz.zcu.fav.kiv.antipatterndetectionapp.controller.management;
+
+import cz.zcu.fav.kiv.antipatterndetectionapp.service.ProjectService;
+import cz.zcu.fav.kiv.antipatterndetectionapp.utils.Utils;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.management.Commit;
+import cz.zcu.fav.kiv.antipatterndetectionapp.repository.managment.CommitRepository;
+import cz.zcu.fav.kiv.antipatterndetectionapp.repository.managment.ConfigurationPersonRelationRepository;
+import cz.zcu.fav.kiv.antipatterndetectionapp.service.managment.BranchService;
+import cz.zcu.fav.kiv.antipatterndetectionapp.service.managment.CommitService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.servlet.mvc.support.RedirectAttributes;
+
+import javax.servlet.http.HttpSession;
+
+/**
+ * This class contains all endpoints of release.html
+ */
+@Controller
+public class ReleaseController {
+
+    private final Logger LOGGER = LoggerFactory.getLogger(ReleaseController.class);
+
+    @Autowired
+    private ProjectService projectService;
+
+    @Autowired
+    private CommitService commitService;
+
+    @Autowired
+    private BranchService branchService;
+
+    @Autowired
+    private CommitRepository commitRepository;
+
+    @Autowired
+    private ConfigurationPersonRelationRepository configurationPersonRelationRepository;
+
+    /**
+     * Method for visualization of released configurations
+     * @param model     Object for passing data to the UI
+     * @param project   Selected project for showing releases
+     * @param session   Session with attributes
+     * @return          HTML template
+     */
+    @GetMapping("/management/release")
+    public String releases(Model model,
+                           @RequestParam(value = "selectedProject", required = false) Long project,
+                           HttpSession session) {
+
+        // First open in session
+        if(project == null && session.getAttribute("project") == null) {
+            model.addAttribute("projects", projectService.getAllProjects());
+            LOGGER.info("@GetMapping(\"/management/release\") - Accessing page");
+            return "management/release";
+        }
+
+        // Project selected
+        if(project != null) {
+            session.setAttribute("project", project);
+            Utils.sessionRecreate(session);
+        }
+
+        project = (long) session.getAttribute("project");
+        model.addAttribute("projectId", project);
+
+        model.addAttribute("projects", projectService.getAllProjects());
+        model.addAttribute("commits", commitRepository.getReleasedCommitsByProject(project));
+        return "management/release";
+    }
+
+    /**
+     * Method opening specific commit based on identifier
+     * @param model         Object for passing data to the UI
+     * @param identifier    Identifier of commit for visualisation
+     * @param redirectAttrs Attributes for redirection
+     * @param session       Session with attributes
+     * @return              HTML template
+     */
+    @PostMapping(value = "/openCommit")
+    public String openCommit(Model model,
+                             @RequestParam(value = "identifier", required = false) String identifier,
+                             RedirectAttributes redirectAttrs,
+                             HttpSession session) {
+
+        Commit commit = commitService.getCommitByIdentifier((long) session.getAttribute("project"), identifier);
+        if(commit == null) {
+            redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Commit doesn't exist");
+            LOGGER.info("@PostMapping(\"/management/release/\") - Commit not found");
+            return "redirect:/management/release";
+        }
+
+        model.addAttribute("selectedCommit", commit);
+        model.addAttribute("committedBy", configurationPersonRelationRepository.getCommittedRelation(commit.getId()));
+        return "management/commit";
+    }
+
+    /**
+     * Method changing release attribute of specific commit
+     * @param model         Object for passing data to the UI
+     * @param identifier    Identifier of commit for attribute change
+     * @param release       Value of attribute release
+     * @param redirectAttrs Attributes for redirection
+     * @param session       Session with attributes
+     * @return              HTML template
+     */
+    @PostMapping(value = "/changeRelease")
+    public String changeRelease(Model model,
+                                @RequestParam(value = "identifier", required = false) String identifier,
+                                @RequestParam(value = "release", required = false) boolean release,
+                                RedirectAttributes redirectAttrs,
+                                HttpSession session) {
+
+        Commit commit = commitService.getCommitByIdentifier((long) session.getAttribute("project"), identifier);
+        if(commit == null) {
+            redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Commit doesn't exist");
+            LOGGER.info("@PostMapping(\"/management/release/\") - Commit not found");
+            return "redirect:/management/release";
+        }
+
+        if(release != commit.isRelease()) {
+            commit.setRelease(release);
+            commitService.saveCommit(commit);
+        }
+
+        LOGGER.info("@PostMapping(\"/management/person\") - Commit " + commit.getIdentifier() + " were unreleased");
+        model.addAttribute("selectedCommit", commit);
+        model.addAttribute("committedBy", configurationPersonRelationRepository.getCommittedRelation(commit.getId()));
+        return "management/commit";
+    }
+
+    /**
+     * Method for marking commit as not released
+     * @param model         Object for passing data to the UI
+     * @param submitId      ID of commit for unreleasing
+     * @param redirectAttrs Attributes for redirection
+     * @return
+     */
+    @PostMapping(value = "/unRelease")
+    public String unRelease(Model model,
+                            @RequestParam(value = "submitId", required = false) Long submitId,
+                            RedirectAttributes redirectAttrs) {
+
+        Commit commit = commitService.getCommitById(submitId);
+        if(commit == null) {
+            redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Submitted commit id doesn't exists");
+            LOGGER.info("@PostMapping(\"/management/release/\") - Commit not found");
+            return "redirect:/management/release";
+        }
+
+        commit.setRelease(false);
+        commitService.saveCommit(commit);
+
+        redirectAttrs.addFlashAttribute("successMessage", "Commit " + commit.getIdentifier() + " were unreleased");
+        LOGGER.info("@PostMapping(\"/management/person\") - Commit " + commit.getIdentifier() + " were unreleased");
+        return "redirect:/management/release";
+    }
+
+}

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/controller/management/SegmentActivityController.java

@@ +1 @@
+package cz.zcu.fav.kiv.antipatterndetectionapp.controller.management;
+
+import cz.zcu.fav.kiv.antipatterndetectionapp.Constants;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.Project;
+import cz.zcu.fav.kiv.antipatterndetectionapp.service.ProjectService;
+import cz.zcu.fav.kiv.antipatterndetectionapp.utils.Utils;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.management.Activity;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.management.Category;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.management.ProjectInstance;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.management.WorkUnit;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.management.enums.WuType;
+import cz.zcu.fav.kiv.antipatterndetectionapp.repository.managment.ActivityRepository;
+import cz.zcu.fav.kiv.antipatterndetectionapp.repository.managment.WorkUnitRepository;
+import cz.zcu.fav.kiv.antipatterndetectionapp.service.managment.ActivityService;
+import cz.zcu.fav.kiv.antipatterndetectionapp.service.managment.CategoryService;
+import cz.zcu.fav.kiv.antipatterndetectionapp.service.managment.WorkUnitService;
+import cz.zcu.fav.kiv.antipatterndetectionapp.service.managment.enums.WuTypeService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.servlet.mvc.support.RedirectAttributes;
+
+import javax.servlet.http.HttpSession;
+import java.util.*;
+
+/**
+ * This class contains all endpoints of segment-activity.html
+ */
+@Controller
+public class SegmentActivityController {
+
+    private final Logger LOGGER = LoggerFactory.getLogger(SegmentActivityController.class);
+
+    @Autowired
+    private ProjectService projectService;
+
+    @Autowired
+    private ActivityService activityService;
+
+    @Autowired
+    private WorkUnitService workUnitService;
+
+    @Autowired
+    private CategoryService categoryService;
+
+    @Autowired
+    private WuTypeService wuTypeService;
+
+    @Autowired
+    private ActivityRepository activityRepository;
+
+    @Autowired
+    private WorkUnitRepository workUnitRepository;
+
+    /**
+     * Method for visualization of activities and work units
+     * @param model         Object for passing data to the UI
+     * @param project       Selected project for showing workunits and activities
+     * @param redirectAttrs Attributes for redirection
+     * @param session       Session with attributes
+     * @return              HTML template
+     */
+    @GetMapping("/management/segment-activity")
+    public String changeProject(Model model,
+                                @RequestParam(value = "selectedProject", required = false) Long project,
+                                RedirectAttributes redirectAttrs,
+                                HttpSession session) {
+
+        // Remove activity if different project selected
+        if(project != null && session.getAttribute("project") != project) {
+            Utils.sessionRecreate(session);
+        }
+
+        // First open in session
+        if(project == null && session.getAttribute("project") == null) {
+            model.addAttribute("projects", projectService.getAllProjects());
+            LOGGER.info("@GetMapping(\"/management/segment-activity\") - Accessing page");
+            return "management/segment-activity";
+        }
+
+        // Project selected
+        if(project != null) {
+            session.setAttribute("project", project);
+        }
+
+        project = (long) session.getAttribute("project");
+
+        Project foundedProject = projectService.getProjectById(project);
+
+        if(foundedProject == null) {
+            if(!Objects.equals(project, Constants.DEFAULT_ID)) {
+                redirectAttrs.addFlashAttribute("errorMessage", "Project not found");
+                LOGGER.info("@GetMapping(\"/management/segment-activity\")- Project not found");
+            } else {
+                session.removeAttribute("activity");
+                LOGGER.info("@GetMapping(\"/management/segment-activity\") - Accessing page");
+            }
+            model.addAttribute("projects", projectService.getAllProjects());
+            return "management/segment-activity";
+        }
+
+        applyFilter(model, foundedProject, session);
+
+        model.addAttribute("activities", foundedProject.getActivities());
+        model.addAttribute("projects", projectService.getAllProjects());
+        return "management/segment-activity";
+    }
+
+    /**
+     * Method for selection of activity
+     * @param model         Object for passing data to the UI
+     * @param activityId    Selected activity for assigning
+     * @param redirectAttrs Attributes for redirection
+     * @param session       Session with attributes
+     * @return              HTML template
+     */
+    @PostMapping("/selectActivity")
+    public String selectActivity(Model model,
+                                 @RequestParam(value = "submitId", required = false) Long activityId,
+                                 RedirectAttributes redirectAttrs,
+                                 HttpSession session) {
+
+        Activity activity = activityService.getActivityById(activityId);
+        if(activity == null) {
+            redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Activity not found");
+            LOGGER.info("@GetMapping(\"/management/segment-activity\")- Activity not found");
+            return "redirect:/management/segment-activity";
+        }
+
+        session.setAttribute("activity", activity);
+        LOGGER.info("@GetMapping(\"/management/segment-activity\") - Accessing page");
+        return "redirect:/management/segment-activity";
+    }
+
+    /**
+     * Method for reselection of activity (removing activity from session)
+     * @param session   Session with attributes
+     * @return          HTML template
+     */
+    @PostMapping("/reselectActivity")
+    public String reselectActivity(HttpSession session) {
+        session.removeAttribute("activity");
+        return "redirect:/management/segment-activity";
+    }
+
+    /**
+     * Method adding category to the filter for current work units
+     * @param model         Object for passing data to the UI
+     * @param categoryId    Identifier of type that will be added
+     * @param session       Session with attributes
+     * @return              HTML template
+     */
+    @PostMapping("/addCategoryFilter")
+    public String addCategory(Model model,
+                              @RequestParam(value = "selectedCategory", required = false) Long categoryId,
+                              HttpSession session) {
+
+        List<Category> categoryFilter = (List<Category>) session.getAttribute("categoryFilter");
+        if(categoryFilter == null) {
+            categoryFilter = new ArrayList<>();
+        }
+
+        Category category = categoryService.getCategoryById(categoryId);
+        if(category != null) {
+            categoryFilter.add(category);
+        }
+        session.setAttribute("categoryFilter", categoryFilter);
+        return "redirect:/management/segment-activity";
+    }
+
+    /**
+     * Method removing category from filter for current work units
+     * @param model         Object for passing data to the UI
+     * @param categoryId    Identifier of category that will be removed
+     * @param session       Session with attributes
+     * @return              HTML template
+     */
+    @PostMapping("/removeCategoryFilter")
+    public String removeCategory(Model model,
+                                 @RequestParam(value = "selectedCategory", required = false) Long categoryId,
+                                 HttpSession session) {
+
+
+        List<Category> categoryFilter = (List<Category>) session.getAttribute("categoryFilter");
+        if(categoryFilter == null) {
+            return "redirect:/management/segment-activity";
+        }
+
+        Category category = categoryService.getCategoryById(categoryId);
+        if(category != null) {
+            categoryFilter.remove(category);
+        }
+        session.setAttribute("categoryFilter", categoryFilter);
+        return "redirect:/management/segment-activity";
+    }
+
+    /**
+     * Method adding type to the filter for current work units
+     * @param model     Object for passing data to the UI
+     * @param typeId    Identifier of type that will be added
+     * @param session   Session with attributes
+     * @return          HTML template
+     */
+    @PostMapping("/addTypeFilter")
+    public String addType(Model model,
+                          @RequestParam(value = "selectedType", required = false) Long typeId,
+                          HttpSession session) {
+
+        List<WuType> typeFilter = (List<WuType>) session.getAttribute("typeFilter");
+        if(typeFilter == null) {
+            typeFilter = new ArrayList<>();
+        }
+
+        WuType wuType = wuTypeService.getWuTypeById(typeId);
+        if(wuType != null) {
+            typeFilter.add(wuType);
+        }
+        session.setAttribute("typeFilter", typeFilter);
+        return "redirect:/management/segment-activity";
+    }
+
+    /**
+     * Method removing type from filter for current work units
+     * @param model     Object for passing data to the UI
+     * @param typeId    Identifier of type that will be removed
+     * @param session   Session with attributes
+     * @return          HTML template
+     */
+    @PostMapping("/removeTypeFilter")
+    public String removeType(Model model,
+                             @RequestParam(value = "selectedType", required = false) Long typeId,
+                             HttpSession session) {
+
+        List<WuType> typeFilter = (List<WuType>) session.getAttribute("typeFilter");
+        if(typeFilter == null) {
+            return "redirect:/management/segment-activity";
+        }
+
+        WuType wuType = wuTypeService.getWuTypeById(typeId);
+        if(wuType != null) {
+            typeFilter.remove(wuType);
+        }
+        session.setAttribute("typeFilter", typeFilter);
+        return "redirect:/management/segment-activity";
+    }
+
+    /**
+     * Method assigning activity to selected work units
+     * @param model         Object for passing data to the UI
+     * @param selectedUnits Selected work units
+     * @param redirectAttrs Attributes for redirection
+     * @param session       Session with attributes
+     * @return              HTML template
+     */
+    @PostMapping("/assignActivity")
+    public String assignActivity(Model model,
+                                 @RequestParam(value = "selectedUnits", required = false) List<WorkUnit> selectedUnits,
+                                 RedirectAttributes redirectAttrs,
+                                 HttpSession session) {
+
+        if(selectedUnits == null || selectedUnits.isEmpty()) {
+            selectedUnits = (List<WorkUnit>) session.getAttribute("selectedWU");
+            session.removeAttribute("selectedWU");
+            if(selectedUnits == null || selectedUnits.isEmpty()) {
+                redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Nothing was selected");
+                LOGGER.info("@PostMapping(\"/management/segment-activity\" - Nothing was selected");
+                return "redirect:/management/segment-activity";
+            }
+        }
+
+        Activity activity = (Activity) session.getAttribute("activity");
+        if(activity != null) {
+
+            for(WorkUnit workUnit : selectedUnits) {
+                workUnit.setActivity(activity);
+                workUnitService.saveWorkUnit(workUnit);
+            }
+
+        } else {
+            redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Error occurred while getting selected activity");
+            LOGGER.info("@PostMapping(\"/management/segment-activity\" - Session has problem with activity extract");
+            return "redirect:/management/segment-activity";
+        }
+
+        redirectAttrs.addFlashAttribute("successMessage", "Activity was assigned to all selected work units (" + selectedUnits.size() + ")");
+        LOGGER.info("@PostMapping(\"/management/segment-activity\" - Activity was assigned to all selected work units");
+        return "redirect:/management/segment-activity";
+    }
+
+    /**
+     * Method testing if there are some work units with activities
+     * @param model         Object for passing data to the UI
+     * @param selectedUnits Selected work units
+     * @param redirectAttrs Attributes for redirection
+     * @param session       Session with attributes
+     * @return              HTML template
+     */
+    @PostMapping("/testWU")
+    public String testWU(Model model,
+                         @RequestParam(value = "selectedUnits", required = false) List<WorkUnit> selectedUnits,
+                         RedirectAttributes redirectAttrs,
+                         HttpSession session) {
+
+        if(selectedUnits == null || selectedUnits.isEmpty()) {
+            redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Nothing was selected");
+            LOGGER.info("@PostMapping(\"/management/segment-activity\" - Nothing was selected");
+            return "redirect:/management/segment-activity";
+        }
+
+        List<Long> ids = new ArrayList<>();
+        boolean notEmpty = false;
+        for(WorkUnit workUnit : selectedUnits) {
+            ids.add(workUnit.getId());
+            if(workUnit.getActivity() != null) {
+                notEmpty = true;
+            }
+        }
+
+        if(notEmpty) {
+            session.setAttribute("selectedWU", selectedUnits);
+            redirectAttrs.addFlashAttribute("selectedWU", selectedUnits);
+            redirectAttrs.addFlashAttribute("selectedIds", ids);
+            return "redirect:/management/segment-activity";
+        }
+
+        return assignActivity(model, selectedUnits, redirectAttrs, session);
+    }
+
+    /**
+     * Method for applying filters defined by user into model
+     * @param model             Object for passing data to the UI
+     * @param foundedProject    Selected project for showing template
+     * @param session           Session with attributes
+     */
+    private void applyFilter(Model model,
+                             Project foundedProject,
+                             HttpSession session) {
+
+        Set<Category> categories = new HashSet<>();
+        Set<WuType> types = new HashSet<>();
+        for(ProjectInstance instance : foundedProject.getProjectInstances()) {
+            categories.addAll(instance.getCategories());
+            types.addAll(instance.getWuTypes());
+        }
+
+        //Remove categories in filter
+        List<Category> categoryList = new ArrayList<>(categories);
+        List<Category> categoryFilter = (List<Category>) session.getAttribute("categoryFilter");
+        if(categoryFilter != null) {
+            categoryFilter.forEach(categoryList::remove);
+        }
+
+        List<WuType> wuTypeList = new ArrayList<>(types);
+        List<WuType> wuTypeFilter = (List<WuType>) session.getAttribute("typeFilter");
+        if(wuTypeFilter != null) {
+            wuTypeFilter.forEach(wuTypeList::remove);
+        }
+
+        //Sort categories and types
+        Collections.sort(categoryList, Comparator.comparing(Category::getName, String.CASE_INSENSITIVE_ORDER));
+        Collections.sort(wuTypeList, Comparator.comparing(WuType::getName, String.CASE_INSENSITIVE_ORDER));
+
+        List<Long> categoryFilterId = new ArrayList<>();
+        List<Long> wuTypeFilterId = new ArrayList<>();
+
+        if(categoryFilter != null) {
+            for(Category category : categoryFilter) {
+                categoryFilterId.add(category.getId());
+            }
+        }
+
+        if(wuTypeFilter != null) {
+            for(WuType type : wuTypeFilter) {
+                wuTypeFilterId.add(type.getId());
+            }
+        }
+
+        if(session.getAttribute("categoryFilter") != null && !categoryFilter.isEmpty() && session.getAttribute("typeFilter") != null && !wuTypeFilter.isEmpty()) {
+            model.addAttribute("workunits", workUnitRepository.getFiltredWorkUnits(foundedProject.getId(), categoryFilterId, wuTypeFilterId, categoryFilterId.size()));
+        } else if(session.getAttribute("categoryFilter") != null && !categoryFilter.isEmpty()) {
+            model.addAttribute("workunits", workUnitRepository.getCategoryFiltredWorkUnits(foundedProject.getId(), categoryFilterId, categoryFilterId.size()));
+        } else if(session.getAttribute("typeFilter") != null && !wuTypeFilter.isEmpty()) {
+            model.addAttribute("workunits", workUnitRepository.getTypeFiltredWorkUnits(foundedProject.getId(), wuTypeFilterId));
+        } else {
+            model.addAttribute("workunits", foundedProject.getWorkUnits());
+        }
+
+        model.addAttribute("categories", categoryList);
+        model.addAttribute("types", wuTypeList);
+    }
+}

src/main/java/cz/zcu/fav/kiv/antipatterndetectionapp/controller/management/SegmentCategoryController.java

@@ +1 @@
+package cz.zcu.fav.kiv.antipatterndetectionapp.controller.management;
+
+import cz.zcu.fav.kiv.antipatterndetectionapp.Constants;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.Project;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.management.*;
+import cz.zcu.fav.kiv.antipatterndetectionapp.service.ProjectService;
+import cz.zcu.fav.kiv.antipatterndetectionapp.service.managment.*;
+import cz.zcu.fav.kiv.antipatterndetectionapp.utils.Utils;
+import cz.zcu.fav.kiv.antipatterndetectionapp.model.management.interfaces.DatabaseObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.util.Pair;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.servlet.mvc.support.RedirectAttributes;
+
+import javax.servlet.http.HttpSession;
+import java.util.*;
+
+/**
+ * This class contains all endpoints of segment-category.html
+ */
+@Controller
+public class SegmentCategoryController {
+
+    private final Logger LOGGER = LoggerFactory.getLogger(SegmentCategoryController.class);
+
+    @Autowired
+    private CategoryService categoryService;
+
+    @Autowired
+    private IterationService iterationService;
+
+    @Autowired
+    private PhaseService phaseService;
+
+    @Autowired
+    private ActivityService activityService;
+
+    @Autowired
+    private ProjectService projectService;
+
+    @Autowired
+    private ProjectInstanceService projectInstanceService;
+
+    @Autowired
+    private WorkUnitService workUnitService;
+
+    /**
+     * Method for showing category page for specific project
+     * @param model         Object for passing data to the UI
+     * @param project       Selected project for showing categories
+     * @param redirectAttrs Attributes for redirection
+     * @return              HTML template
+     */
+    @GetMapping("/management/segment-category")
+    public String category(Model model,
+                                @RequestParam(value = "selectedProject", required = false) Long project,
+                                RedirectAttributes redirectAttrs,
+                                HttpSession session) {
+
+        // First open in session
+        if(project == null && session.getAttribute("project") == null) {
+            model.addAttribute("projects", projectService.getAllProjects());
+            LOGGER.info("@GetMapping(\"/management/segment-category\") - Accessing page");
+            return "management/segment-category";
+        }
+
+        // Project selected
+        if(project != null) {
+            session.setAttribute("project", project);
+            Utils.sessionRecreate(session);
+        }
+
+        project = (long) session.getAttribute("project");
+
+        Project foundedProject = projectService.getProjectById(project);
+        if(foundedProject == null) {
+            if(!Objects.equals(project, Constants.DEFAULT_ID)) {
+                redirectAttrs.addFlashAttribute("errorMessage", "Project not found");
+                LOGGER.info("@GetMapping(\"/management/segment-category/\") - Project not found");
+            } else {
+                LOGGER.info("@GetMapping(\"/management/segment-category/\") - Accessing page");
+            }
+            model.addAttribute("projects", projectService.getAllProjects());
+            return "management/segment-category";
+        }
+
+        //Add all categories into model
+        List<Category> categories = new ArrayList<>();
+        for(ProjectInstance projectInstance : foundedProject.getProjectInstances()) {
+            categories.addAll(projectInstance.getCategories());
+        }
+        Collections.sort(categories, Comparator.comparing(Category::getName, String.CASE_INSENSITIVE_ORDER));
+
+        model.addAttribute("categories", categories);
+        model.addAttribute("projects", projectService.getAllProjects());
+        LOGGER.info("@GetMapping(\"/management/segment-category/\") - Accessing page");
+
+        return "/management/segment-category";
+    }
+
+    /**
+     * Method preparing selected categories for transformation into defined type
+     * @param model                 Object for passing data to the UI
+     * @param selectedCategories    List of selected categories
+     * @param submitType            Type of required attribute (1 - Iteration, 2 - Phase, 3 - Activity)
+     * @param submitId              String with type of required attribute and id of one selected category
+     * @param redirectAttrs         Attributes for redirection
+     * @return                      HTML template
+     */
+    @PostMapping(value = "/categoryChange")
+    public String categoryChange(Model model,
+                                 @RequestParam(value = "selectedBox", required = false) List<Category> selectedCategories,
+                                 @RequestParam(value = "submitType", required = false) Integer submitType,
+                                 @RequestParam(value = "submitId", required = false) String submitId,
+                                 RedirectAttributes redirectAttrs) {
+
+        if(selectedCategories != null && submitType != null) { // Selected submit
+
+            if(submitType <= 0 || submitType > Constants.SUBMIT_TYPES) { // ERROR: Unknown submitType
+                redirectAttrs.addFlashAttribute("errorMessage", "ERROR: Application error occurred");
+                LOGGER.warn("@PostMapping(\"/management/segment-category\") - Cannot proceed: Unknown submitType " + submitType);
+                return "redirect:/management/segment-category";
+            }
+
+        } else if(submitId != null) { //Inline submit
+
+            Pair<Integer, Long> resultPair = extractTypeAndId(submitId);