42 change decision tree

src/main/java/de/muenchen/kobit/backend/competence/Competence.java

@@ -67,20 +67,20 @@ public enum Competence {
 
     // reasons of discrimination
     ETHNIC_RACIAL(
-            "Diskriminierung aufgrund ethnischer oder rassistischer Motive, Religion oder"
-                    + " Weltanschauung, Alter",
-            ""),
-    DISABLED("Diskriminierung aufgrund Behinderung", ""),
-    SEXUAL_IDENTITY("Diskriminierung aufgrund sexueller oder geschlechtlicher Identität", ""),
+            "wegen rassistischer Motive, der ethnischen Herkunft, Religion, Weltanschauung", ""),
+    DISABLED("wegen Behinderung", ""),
+    SEXUAL_IDENTITY("wegen der sexuellen Identität", ""),
+    AGE("wegen des Alters", ""),
+    SEXUALITY("wegen des Geschlechts", ""),
 
     // sexual discrimination
     EQUALITY("Gleichstellung Mann Frau", ""),
     LGBTIQ("LGBTIQ*", ""),
 
     // Health Issues
-    ADDICTION("Suchtproblem", ""),
-    PHYSICAL("körperliches Problem", ""),
-    PSYCHOLOGICAL("psychisches Problem", "");
+    ADDICTION("Sucht", ""),
+    PHYSICAL("Körperliche Probleme", ""),
+    PSYCHOLOGICAL("Psychische Probleme", "");
 
     public final String germanDescription;
     public final String shortDescription;

src/main/java/de/muenchen/kobit/backend/competence/service/CompetenceService.java

@@ -41,22 +41,10 @@ public class CompetenceService {
     }
 
     public List<ContactPointView> findAllContactPointsForCompetences(
-            List<Competence> competences, String department) {
-        Set<UUID> keys = getContactPointIds(competences);
-        if (isSpecialCase(competences)) {
-            keys.addAll(specialCaseContactPoints(competences));
-        }
-        return getMatchingContactPoints(department, keys).stream()
-                .map(mapper::contactPointToView)
-                .collect(Collectors.toList());
-    }
+            List<UUID> foundCPs, List<Competence> competences, String department) {
+        Set<UUID> keys = new HashSet<>(foundCPs);
 
-    public List<ContactPointView> findAllContactPointsForCompetences(List<Competence> competences) {
-        Set<UUID> keys = getContactPointIds(competences);
-        if (isSpecialCase(competences)) {
-            keys.addAll(specialCaseContactPoints(competences));
-        }
-        return contactPointRepository.findAllByIdIn(keys).stream()
+        return getMatchingContactPoints(department, keys).stream()
                 .map(mapper::contactPointToView)
                 .collect(Collectors.toList());
     }
@@ -68,6 +56,7 @@ public List<Competence> findAllCompetencesForId(UUID contactPointId) {
     }
 
     private List<ContactPoint> getMatchingContactPoints(String department, Set<UUID> keys) {
+
         log.debug("getMatchingContactPoints | department {}", department);
         if (department == null) {
             return keys.stream()
@@ -86,6 +75,15 @@ private List<ContactPoint> getMatchingContactPoints(String department, Set<UUID>
                 .collect(toList());
     }
 
+    // Extremly hacky workaround for trashy datastructure - please improve in the future
+    public Competence getCompetenceByEnumString(String enumAsString) {
+        String splittedString = enumAsString.split("\\.")[1].split("\\(")[0];
+
+        log.debug("getCompetenceByEnumString | splittedString {}", splittedString);
+
+        return Competence.valueOf(splittedString);
+    }
+
     @Transactional
     public void deleteCompetencesByContactPointId(UUID contactPointId) {
         competenceRepository.deleteAllByContactPointId(contactPointId);
@@ -98,6 +96,7 @@ public void deleteCompetenceAndContactPointPair(
                 it -> competenceRepository.deleteByContactPointIdAndCompetence(contactPointId, it));
     }
 
+    @Transactional
     public void createCompetenceToContactPoint(UUID contactPointId, Competence competence) {
         createCompetenceToContactPoint(new CompetenceToContactPoint(contactPointId, competence));
     }
@@ -124,31 +123,4 @@ private Set<UUID> getContactPointIds(List<Competence> competences) {
         }
         return matchingKeys;
     }
-
-    /**
-     * @param competences - list of competences selected in the decision tree
-     * @return true if a special case is given A special case are some contact points for juniors.
-     *     These are not only responsible for the Juniors, they are also responsible if an executive
-     *     or employee has a problem with a junior.
-     */
-    private boolean isSpecialCase(List<Competence> competences) {
-        return ((competences.contains(Competence.EXECUTIVE)
-                        && competences.contains(Competence.OPPOSITE_JUNIOR))
-                || (competences.contains(Competence.EMPLOYEE)
-                        && competences.contains(Competence.OPPOSITE_JUNIOR)));
-    }
-
-    private Set<UUID> specialCaseContactPoints(List<Competence> competences) {
-        if (competences.contains(Competence.EXECUTIVE)
-                && competences.contains(Competence.OPPOSITE_JUNIOR)) {
-            competences.remove(Competence.EXECUTIVE);
-            competences.add(Competence.EXECUTIVE_JUNIOR);
-        }
-        if (competences.contains(Competence.EMPLOYEE)
-                && competences.contains(Competence.OPPOSITE_JUNIOR)) {
-            competences.remove(Competence.EMPLOYEE);
-            competences.add(Competence.EMPLOYEE_JUNIOR);
-        }
-        return getContactPointIds(competences);
-    }
 }

src/main/java/de/muenchen/kobit/backend/contactpoint/service/ContactPointManipulationService.java

@@ -12,6 +12,9 @@
 import de.muenchen.kobit.backend.contactpoint.repository.ContactPointRepository;
 import de.muenchen.kobit.backend.contactpoint.view.ContactPointView;
 import de.muenchen.kobit.backend.contactpoint.view.ListItemToCompetenceView;
+import de.muenchen.kobit.backend.decisiontree.relevance.model.Path;
+import de.muenchen.kobit.backend.decisiontree.relevance.model.Relevance;
+import de.muenchen.kobit.backend.decisiontree.relevance.model.RelevanceCompetence;
 import de.muenchen.kobit.backend.decisiontree.relevance.service.RelevanceService;
 import de.muenchen.kobit.backend.decisiontree.relevance.view.RelevanceOrder;
 import de.muenchen.kobit.backend.decisiontree.relevance.view.RelevanceView;
@@ -22,11 +25,7 @@
 import de.muenchen.kobit.backend.validation.exception.ContactPointValidationException;
 import de.muenchen.kobit.backend.validation.exception.contactpoint.InvalidCompetenceException;
 import de.muenchen.kobit.backend.validation.exception.contactpoint.InvalidContactPointException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.UUID;
+import java.util.*;
 import java.util.stream.Collectors;
 import javax.persistence.EntityNotFoundException;
 import org.slf4j.Logger;
@@ -83,10 +82,105 @@ public void updateContactPointCompetence(List<ListItemToCompetenceView> competen
         log.debug("updateContactPointCompetence | competences: {}", competences.toString());
         log.debug(
                 "updateContactPointCompetence | competencesViews: {}", competenceViews.toString());
-        removeContactPointsForCompetence(competences);
-        updateRelevance(competenceViews, competences);
+        /**
+         * For one cp (A) and curent Path (P) and Competences (COM) 1. Get all paths of A expect the
+         * P 2. Get a unique (optional) list of all the competences from all Paths from 1. 3. Get
+         * all competences COM of Path P 4. Subtract all competences (of 2.) from COM 5. Remove the
+         * competences of 4. from the contactpoint A
+         */
+        List<UUID> cpToUpdate = getContactPointsToUpdate(competenceViews, competences);
+
+        log.debug("updateContactPointCompetence | CPs to update: {}", cpToUpdate.toString());
+
+        cpToUpdate.forEach(cp -> removeUnusedCompetences(cp, competences));
+
+        /* competenceViews.forEach(
+        competenceView ->
+                removeUnusedCompetences(competenceView.getListItem(), competences));*/
+
         competenceViews.forEach(
-                it -> saveNewCompetencePair(it.getListItem().getId(), it.getCompetences()));
+                listItemToCompetenceView ->
+                        saveNewCompetencePair(
+                                listItemToCompetenceView.getListItem().getId(),
+                                listItemToCompetenceView
+                                        .getCompetences())); // set new competences for all
+        updateRelevance(competenceViews, competences);
+    }
+
+    private List<UUID> getContactPointsToUpdate(
+            List<ListItemToCompetenceView> competenceViews, List<Competence> competences) {
+        Path currentPath = relevanceService.getPath(new HashSet<>(competences));
+        if (currentPath == null) {
+            return Collections.emptyList();
+        }
+        log.debug("cpManipulation | pathID: {}", currentPath.getId());
+
+        List<UUID> currentCPIds =
+                relevanceService.getAllRelevancesByPathId(currentPath.getId()).stream()
+                        .map(Relevance::getContactPointId)
+                        .collect(Collectors.toList());
+        log.debug("getContactPointsToUpdate | currentCPIds: {}", currentCPIds);
+
+        List<UUID> receivedCPIds =
+                competenceViews.stream()
+                        .map(cpv -> cpv.getListItem().getId())
+                        .collect(Collectors.toList());
+        log.debug("getContactPointsToUpdate | receivedCPIds: {}", receivedCPIds);
+
+        currentCPIds.removeAll(receivedCPIds);
+
+        return currentCPIds;
+    }
+
+    private void removeUnusedCompetences(UUID cpID, List<Competence> competences) {
+        log.debug("removeUnusedCompetences | competences: {}", competences.toString());
+        Path currentPath = relevanceService.getPath(new HashSet<>(competences));
+        if (currentPath == null) {
+            return;
+        }
+        log.debug("removeUnusedCompetences | currentPath: {}", currentPath.getId().toString());
+
+        Set<RelevanceCompetence> otherRelevanceCompetences =
+                relevanceService.getAllRelevancesByContactPointId(cpID).stream()
+                        .filter(relevance -> !relevance.getPathId().equals(currentPath.getId()))
+                        .map(
+                                relevance ->
+                                        relevanceService.getAllRelevanceCompetencesByPathId(
+                                                relevance.getPathId()))
+                        .flatMap(Collection::stream)
+                        .collect(Collectors.toSet());
+        log.debug(
+                "removeUnusedCompetences | otherRelevanceCompetences: {}",
+                otherRelevanceCompetences.stream()
+                        .map(RelevanceCompetence::getId)
+                        .collect(Collectors.toList()));
+
+        HashSet<RelevanceCompetence> toRemove = new HashSet<>(currentPath.getCompetences());
+        log.debug(
+                "removeUnusedCompetences | toRemove: {}",
+                toRemove.stream().map(RelevanceCompetence::getId).collect(Collectors.toList()));
+
+        toRemove.removeAll(otherRelevanceCompetences);
+
+        log.debug(
+                "removeUnusedCompetences | toRemove: {}",
+                toRemove.stream()
+                        .map(RelevanceCompetence::getCompetence)
+                        .collect(Collectors.toList())
+                        .toString());
+
+        List<Competence> competencesToRemove =
+                toRemove.stream()
+                        .map(
+                                relevanceCompetence ->
+                                        competenceService.getCompetenceByEnumString(
+                                                relevanceCompetence.getCompetence()))
+                        .collect(Collectors.toList());
+        log.debug(
+                "removeUnusedCompetences | competencesToRemove: {}",
+                competencesToRemove.toString());
+
+        competenceService.deleteCompetenceAndContactPointPair(cpID, competencesToRemove);
     }
 
     private void updateRelevance(
@@ -145,15 +239,6 @@ private void validateId(UUID contactPointId, UUID pathID) throws InvalidContactP
         }
     }
 
-    private void removeContactPointsForCompetence(List<Competence> competences) {
-        List<ContactPointView> existingCompetences =
-                competenceService.findAllContactPointsForCompetences(competences);
-        existingCompetences.forEach(
-                it ->
-                        competenceService.deleteCompetenceAndContactPointPair(
-                                it.getId(), competences));
-    }
-
     private void saveNewCompetencePair(UUID id, List<Competence> competences) {
         for (Competence competence : competences) {
             competenceService.createCompetenceToContactPoint(id, competence);

src/main/java/de/muenchen/kobit/backend/decisiontree/branches/DiscriminationBranch.java

@@ -10,37 +10,55 @@
 public class DiscriminationBranch {
 
     private final String roleQuestion = "Welche Rolle haben Sie?";
-    private final String kindOfDiscrimination =
-            "Aus welchem Grund werden Sie/fühlen Sie sich diskriminiert?";
+    private final String kindOfDiscrimination = "Aus welchem Grund fühlen Sie sich diskriminiert?";
     private final String kindOfSexualDiscrimination =
             "Mann-Frau Diskriminierung oder LGBTIQ* Diskriminierung?";
 
+    // Welche Rolle haben Sie?
     private final DecisionPoint n1 =
             new DecisionPoint(
                     Competence.DISCRIMINATION,
                     roleQuestion,
                     List.of(
                             Competence.EMPLOYEE.toCompetenceView(),
+                            Competence.EXECUTIVE.toCompetenceView(),
                             Competence.JUNIOR.toCompetenceView()));
 
+    // Aus welchem grund fühlen Sie sich diskrimiert?
     private final DecisionPoint n2 =
             new DecisionPoint(
                     Competence.EMPLOYEE,
                     kindOfDiscrimination,
                     List.of(
                             Competence.ETHNIC_RACIAL.toCompetenceView(),
+                            Competence.AGE.toCompetenceView(),
                             Competence.DISABLED.toCompetenceView(),
+                            Competence.SEXUALITY.toCompetenceView(),
                             Competence.SEXUAL_IDENTITY.toCompetenceView()));
     private final DecisionPoint n3 =
             new DecisionPoint(
                     Competence.JUNIOR,
                     kindOfDiscrimination,
                     List.of(
                             Competence.ETHNIC_RACIAL.toCompetenceView(),
+                            Competence.AGE.toCompetenceView(),
                             Competence.DISABLED.toCompetenceView(),
+                            Competence.SEXUALITY.toCompetenceView(),
                             Competence.SEXUAL_IDENTITY.toCompetenceView()));
 
     private final DecisionPoint n4 =
+            new DecisionPoint(
+                    Competence.EXECUTIVE,
+                    kindOfDiscrimination,
+                    List.of(
+                            Competence.ETHNIC_RACIAL.toCompetenceView(),
+                            Competence.AGE.toCompetenceView(),
+                            Competence.DISABLED.toCompetenceView(),
+                            Competence.SEXUALITY.toCompetenceView(),
+                            Competence.SEXUAL_IDENTITY.toCompetenceView()));
+
+    // other
+    private final DecisionPoint n5 =
             new DecisionPoint(
                     Competence.SEXUAL_IDENTITY,
                     kindOfSexualDiscrimination,

src/main/java/de/muenchen/kobit/backend/decisiontree/branches/HealthIssuesBranch.java

@@ -9,7 +9,7 @@
 @Component
 public class HealthIssuesBranch {
 
-    private static final String kindOfHealthIssues = "Welches gesundheitliches Problem haben Sie?";
+    private static final String kindOfHealthIssues = "Welches gesundheitliche Problem haben Sie?";
 
     private final DecisionPoint n1 =
             new DecisionPoint(

src/main/java/de/muenchen/kobit/backend/decisiontree/branches/MobbingBranch.java

@@ -13,16 +13,16 @@ public class MobbingBranch {
 
     private final String whoIsMobbing = "Durch wen werden Sie gemobbt/fühlen Sie sich gemobbt?";
 
-    private final String stressQuestion = "Wie hoch ist ihre persönliche Belastung?";
+    private final String stressQuestion = "Wie hoch ist Ihre persönliche Belastung?";
 
     private final DecisionPoint n1 =
             new DecisionPoint(
                     Competence.MOBBING,
                     roleQuestion,
                     List.of(
                             Competence.EMPLOYEE.toCompetenceView(),
-                            Competence.JUNIOR.toCompetenceView(),
-                            Competence.EXECUTIVE.toCompetenceView()));
+                            Competence.EXECUTIVE.toCompetenceView(),
+                            Competence.JUNIOR.toCompetenceView()));
 
     private final DecisionPoint n2 =
             new DecisionPoint(

src/main/java/de/muenchen/kobit/backend/decisiontree/branches/WorkConflictBranch.java

@@ -85,31 +85,6 @@ public class WorkConflictBranch {
                             Competence.STRESS_MEDIUM.toCompetenceView(),
                             Competence.STRESS_HIGH.toCompetenceView()));
 
-    private final DecisionPoint n9 =
-            new DecisionPoint(
-                    Competence.STRESS_HIGH,
-                    escalationIndex,
-                    List.of(
-                            Competence.ESCALATION_LOW.toCompetenceView(),
-                            Competence.ESCALATION_MEDIUM.toCompetenceView(),
-                            Competence.ESCALATION_HIGH.toCompetenceView()));
-    private final DecisionPoint n10 =
-            new DecisionPoint(
-                    Competence.STRESS_MEDIUM,
-                    escalationIndex,
-                    List.of(
-                            Competence.ESCALATION_LOW.toCompetenceView(),
-                            Competence.ESCALATION_MEDIUM.toCompetenceView(),
-                            Competence.ESCALATION_HIGH.toCompetenceView()));
-    private final DecisionPoint n11 =
-            new DecisionPoint(
-                    Competence.STRESS_LOW,
-                    escalationIndex,
-                    List.of(
-                            Competence.ESCALATION_LOW.toCompetenceView(),
-                            Competence.ESCALATION_MEDIUM.toCompetenceView(),
-                            Competence.ESCALATION_HIGH.toCompetenceView()));
-
     private final HashMap<Competence, DecisionPoint> branchMap = new HashMap<>();
 
     public WorkConflictBranch() {
@@ -121,9 +96,6 @@ public WorkConflictBranch() {
         branchMap.put(n6.getCompetence(), n6);
         branchMap.put(n7.getCompetence(), n7);
         branchMap.put(n8.getCompetence(), n8);
-        branchMap.put(n9.getCompetence(), n9);
-        branchMap.put(n10.getCompetence(), n10);
-        branchMap.put(n11.getCompetence(), n11);
     }
 
     public DecisionPoint getNextNode(Competence competence) {