Update RoleAnalysisSession schemas

Evolveum · Jul 27, 2023 · a1f3533 · a1f3533
1 parent 56a5d22
commit a1f3533
Show file tree

Hide file tree

Showing 27 changed files with 339 additions and 314 deletions.
diff --git a/config/sql/native-new/postgres-new.sql b/config/sql/native-new/postgres-new.sql
@@ -1194,11 +1194,9 @@ CREATE INDEX m_role_analysis_cluster_table_similarGroupsCount_idx ON m_role_anal
 CREATE TABLE m_role_analysis_session_table (
     oid UUID NOT NULL PRIMARY KEY REFERENCES m_object_oid(oid),
     objectType ObjectType GENERATED ALWAYS AS ('ROLE_ANALYSIS_SESSION') STORED
-        CHECK (objectType = 'ROLE_ANALYSIS_SESSION'),
-        riskLevel TEXT,
-        processedObjectsCount INTEGER,
-        meanDensity TEXT
-)
+        CHECK (objectType = 'ROLE_ANALYSIS_SESSION')
+
+        )
     INHERITS (m_assignment_holder);
 
 CREATE TRIGGER m_role_analysis_session_table_oid_insert_tr BEFORE INSERT ON m_role_analysis_session_table
@@ -1208,11 +1206,11 @@ CREATE TRIGGER m_role_analysis_session_table_update_tr BEFORE UPDATE ON m_role_a
 CREATE TRIGGER m_role_analysis_session_table_oid_delete_tr AFTER DELETE ON m_role_analysis_session_table
     FOR EACH ROW EXECUTE FUNCTION delete_object_oid();
 
-CREATE INDEX m_role_analysis_session_table_clustersRef_idx ON m_role_analysis_session_table USING gin (clustersRef);
-CREATE INDEX m_role_analysis_session_table_identifier_idx ON m_role_analysis_session_table (identifier);
-CREATE INDEX m_role_analysis_session_table_riskLevel_idx ON m_role_analysis_session_table (riskLevel);
-CREATE INDEX m_role_analysis_session_table_consist_idx ON m_role_analysis_session_table (consist);
-CREATE INDEX m_role_analysis_session_table_density_idx ON m_role_analysis_session_table (density);
+--CREATE INDEX m_role_analysis_session_table_clustersRef_idx ON m_role_analysis_session_table USING gin (clustersRef);
+--CREATE INDEX m_role_analysis_session_table_identifier_idx ON m_role_analysis_session_table (identifier);
+--CREATE INDEX m_role_analysis_session_table_riskLevel_idx ON m_role_analysis_session_table (riskLevel);
+--CREATE INDEX m_role_analysis_session_table_consist_idx ON m_role_analysis_session_table (consist);
+--CREATE INDEX m_role_analysis_session_table_density_idx ON m_role_analysis_session_table (density);
 
 
 -- Represents LookupTableType, see https://docs.evolveum.com/midpoint/reference/misc/lookup-tables/

diff --git a/...com/evolveum/midpoint/gui/impl/page/admin/role/mining/algorithm/ExtractIntersections.java b/...com/evolveum/midpoint/gui/impl/page/admin/role/mining/algorithm/ExtractIntersections.java
@@ -12,20 +12,20 @@
 import com.evolveum.midpoint.gui.impl.page.admin.role.mining.objects.IntersectionObject;
 import com.evolveum.midpoint.gui.impl.page.admin.role.mining.utils.MiningRoleTypeChunk;
 import com.evolveum.midpoint.gui.impl.page.admin.role.mining.utils.MiningUserTypeChunk;
-import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisProcessMode;
-import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisSearchMode;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisProcessModeType;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisSearchModeType;
 
 public class ExtractIntersections {
 
     public static List<IntersectionObject> businessRoleDetection(List<MiningRoleTypeChunk> miningRoleTypeChunks,
             List<MiningUserTypeChunk> miningUserTypeChunks, double minFrequency,
-            double maxFrequency, int minIntersection, Integer minOccupancy, RoleAnalysisProcessMode mode) {
+            double maxFrequency, int minIntersection, Integer minOccupancy, RoleAnalysisProcessModeType mode) {
 
         List<IntersectionObject> intersections = new ArrayList<>();
 
-        if (mode.equals(RoleAnalysisProcessMode.USER)) {
+        if (mode.equals(RoleAnalysisProcessModeType.USER)) {
             loadUsersIntersections(miningRoleTypeChunks, minFrequency, maxFrequency, minIntersection, intersections, minOccupancy);
-        } else if (mode.equals(RoleAnalysisProcessMode.ROLE)) {
+        } else if (mode.equals(RoleAnalysisProcessModeType.ROLE)) {
             loadRolesIntersections(miningUserTypeChunks, minFrequency, maxFrequency, minIntersection, intersections, minOccupancy);
         }
 
@@ -50,7 +50,7 @@ private static void loadUsersIntersections(List<MiningRoleTypeChunk> miningRoleT
             if (size >= minOccupancy) {
                 intersections.add(new IntersectionObject(new HashSet<>(users), size * users.size(),
                         "outer", size,
-                        null, new HashSet<>(), RoleAnalysisSearchMode.INTERSECTION));
+                        null, new HashSet<>(), RoleAnalysisSearchModeType.INTERSECTION));
             }
 
         }
@@ -102,7 +102,7 @@ private static void loadUsersIntersections(List<MiningRoleTypeChunk> miningRoleT
             if (counter >= minOccupancy) {
                 intersections.add(new IntersectionObject(new HashSet<>(users), counter * users.size(),
                         "outer", counter,
-                        null, new HashSet<>(), RoleAnalysisSearchMode.INTERSECTION));
+                        null, new HashSet<>(), RoleAnalysisSearchModeType.INTERSECTION));
             }
         }
 
@@ -122,7 +122,7 @@ private static void loadUsersIntersections(List<MiningRoleTypeChunk> miningRoleT
             if (counter >= minOccupancy) {
                 intersections.add(new IntersectionObject(new HashSet<>(users), counter * users.size(),
                         "inner", counter,
-                        null, new HashSet<>(), RoleAnalysisSearchMode.INTERSECTION));
+                        null, new HashSet<>(), RoleAnalysisSearchModeType.INTERSECTION));
             }
 
         }
@@ -148,7 +148,7 @@ private static void loadRolesIntersections(List<MiningUserTypeChunk> miningUserT
             if (size >= minOccupancy) {
                 intersections.add(new IntersectionObject(new HashSet<>(roles), roles.size() * size,
                         "outer", size,
-                        null, new HashSet<>(), RoleAnalysisSearchMode.INTERSECTION));
+                        null, new HashSet<>(), RoleAnalysisSearchModeType.INTERSECTION));
             }
 
         }
@@ -200,7 +200,7 @@ private static void loadRolesIntersections(List<MiningUserTypeChunk> miningUserT
             if (counter >= minOccupancy) {
                 intersections.add(new IntersectionObject(new HashSet<>(roles), counter * roles.size(),
                         "outer", counter,
-                        null, new HashSet<>(), RoleAnalysisSearchMode.INTERSECTION));
+                        null, new HashSet<>(), RoleAnalysisSearchModeType.INTERSECTION));
             }
         }
 
@@ -221,7 +221,7 @@ private static void loadRolesIntersections(List<MiningUserTypeChunk> miningUserT
             if (counter >= minOccupancy) {
                 intersections.add(new IntersectionObject(new HashSet<>(roles), counter * roles.size(),
                         "inner", counter,
-                        null, new HashSet<>(), RoleAnalysisSearchMode.INTERSECTION));
+                        null, new HashSet<>(), RoleAnalysisSearchModeType.INTERSECTION));
             }
 
         }

diff --git a/.../java/com/evolveum/midpoint/gui/impl/page/admin/role/mining/algorithm/ExtractJaccard.java b/.../java/com/evolveum/midpoint/gui/impl/page/admin/role/mining/algorithm/ExtractJaccard.java
@@ -10,9 +10,9 @@
 import com.evolveum.midpoint.gui.impl.page.admin.role.mining.objects.IntersectionObject;
 import com.evolveum.midpoint.gui.impl.page.admin.role.mining.utils.*;
 
-import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisProcessMode;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisProcessModeType;
 
-import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisSearchMode;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisSearchModeType;
 
 import com.google.common.collect.ArrayListMultimap;
 import com.google.common.collect.ListMultimap;
@@ -23,14 +23,14 @@ public class ExtractJaccard {
 
     public static List<IntersectionObject> businessRoleDetection(List<MiningRoleTypeChunk> miningRoleTypeChunks,
             List<MiningUserTypeChunk> miningUserTypeChunks, double minFrequency,
-            double maxFrequency, int minIntersection, Integer minOccupancy, RoleAnalysisProcessMode mode, double similarity) {
+            double maxFrequency, int minIntersection, Integer minOccupancy, RoleAnalysisProcessModeType mode, double similarity) {
 
         List<IntersectionObject> intersections = new ArrayList<>();
 
-        if (mode.equals(RoleAnalysisProcessMode.USER)) {
+        if (mode.equals(RoleAnalysisProcessModeType.USER)) {
             loadUsersIntersections(miningRoleTypeChunks, minFrequency, maxFrequency, minIntersection, intersections,
                     minOccupancy, similarity);
-        } else if (mode.equals(RoleAnalysisProcessMode.ROLE)) {
+        } else if (mode.equals(RoleAnalysisProcessModeType.ROLE)) {
             loadRolesIntersections(miningUserTypeChunks, minFrequency, maxFrequency, minIntersection, intersections,
                     minOccupancy, similarity);
         }
@@ -56,7 +56,7 @@ private static void loadUsersIntersections(List<MiningRoleTypeChunk> miningRoleT
             if (size >= minOccupancy) {
                 intersections.add(new IntersectionObject(new HashSet<>(users), size * users.size(),
                         "jaccard", size,
-                        null, new HashSet<>(miningRoleTypeChunk.getRoles()), RoleAnalysisSearchMode.JACCARD));
+                        null, new HashSet<>(miningRoleTypeChunk.getRoles()), RoleAnalysisSearchModeType.JACCARD));
             }
 
         }
@@ -88,7 +88,7 @@ private static void loadUsersIntersections(List<MiningRoleTypeChunk> miningRoleT
 
             intersections.add(new IntersectionObject(users, users.size() * roles.size(),
                     "jaccard", roles.size(),
-                    null, roles, RoleAnalysisSearchMode.JACCARD));
+                    null, roles, RoleAnalysisSearchModeType.JACCARD));
         }
 
     }
@@ -113,7 +113,7 @@ private static void loadRolesIntersections(List<MiningUserTypeChunk> miningUserT
             if (occupancy >= minOccupancy) {
                 intersections.add(new IntersectionObject(new HashSet<>(roles), roles.size() * occupancy,
                         "outer", occupancy,
-                        null, new HashSet<>(miningUserTypeChunk.getUsers()), RoleAnalysisSearchMode.JACCARD));
+                        null, new HashSet<>(miningUserTypeChunk.getUsers()), RoleAnalysisSearchModeType.JACCARD));
             }
 
         }
@@ -145,7 +145,7 @@ private static void loadRolesIntersections(List<MiningUserTypeChunk> miningUserT
 
             intersections.add(new IntersectionObject(new HashSet<>(roles), roles.size() * users.size(),
                     "jaccard", users.size(),
-                    null, users, RoleAnalysisSearchMode.JACCARD));
+                    null, users, RoleAnalysisSearchModeType.JACCARD));
         }
 
     }

diff --git a/...eum/midpoint/gui/impl/page/admin/role/mining/algorithm/cluster/ClusterAlgorithmUtils.java b/...eum/midpoint/gui/impl/page/admin/role/mining/algorithm/cluster/ClusterAlgorithmUtils.java
@@ -21,9 +21,9 @@
 
 import com.evolveum.midpoint.gui.impl.page.admin.role.mining.utils.MiningUserTypeChunk;
 
-import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisProcessMode;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisProcessModeType;
 
-import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisSearchMode;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisSearchModeType;
 
 import com.github.openjson.JSONArray;
 import com.github.openjson.JSONObject;
@@ -278,22 +278,22 @@ private static void resolveDefaultIntersection(PageBase pageBase, RoleAnalysisCl
             OperationResult operationResult, ClusterOptions clusterOptions) {
 
         if (clusterOptions != null) {
-            RoleAnalysisProcessMode mode = clusterOptions.getMode();
+            RoleAnalysisProcessModeType mode = clusterOptions.getMode();
             int group = Math.min(clusterOptions.getDefaultOccupancySearch(), clusterOptions.getMinGroupSize());
             int intersection = Math.min(clusterOptions.getDefaultIntersectionSearch(), clusterOptions.getMinIntersections());
             double defaultMaxFrequency = clusterOptions.getDefaultMaxFrequency();
             double defaultMinFrequency = clusterOptions.getDefaultMinFrequency();
-            RoleAnalysisSearchMode searchMode = clusterOptions.getSearchMode();
+            RoleAnalysisSearchModeType searchMode = clusterOptions.getSearchMode();
 
-            if (mode.equals(RoleAnalysisProcessMode.ROLE)) {
+            if (mode.equals(RoleAnalysisProcessModeType.ROLE)) {
                 MiningOperationChunk miningOperationChunk = new MiningOperationChunk(clusterType, pageBase,
-                        RoleAnalysisProcessMode.ROLE, operationResult, true, false);
+                        RoleAnalysisProcessModeType.ROLE, operationResult, true, false);
                 List<MiningRoleTypeChunk> miningRoleTypeChunks = miningOperationChunk.getMiningRoleTypeChunks(
                         ClusterObjectUtils.SORT.NONE);
                 List<MiningUserTypeChunk> miningUserTypeChunks = miningOperationChunk.getMiningUserTypeChunks(
                         ClusterObjectUtils.SORT.NONE);
 
-                if (searchMode.equals(RoleAnalysisSearchMode.JACCARD)) {
+                if (searchMode.equals(RoleAnalysisSearchModeType.JACCARD)) {
                     possibleBusinessRole = ExtractJaccard.businessRoleDetection(miningRoleTypeChunks, miningUserTypeChunks,
                             defaultMinFrequency,
                             defaultMaxFrequency,
@@ -304,15 +304,15 @@ private static void resolveDefaultIntersection(PageBase pageBase, RoleAnalysisCl
                             group, intersection, mode);
                 }
 
-            } else if (mode.equals(RoleAnalysisProcessMode.USER)) {
+            } else if (mode.equals(RoleAnalysisProcessModeType.USER)) {
                 MiningOperationChunk miningOperationChunk = new MiningOperationChunk(clusterType, pageBase,
-                        RoleAnalysisProcessMode.USER, operationResult, true, false);
+                        RoleAnalysisProcessModeType.USER, operationResult, true, false);
                 List<MiningRoleTypeChunk> miningRoleTypeChunks = miningOperationChunk.getMiningRoleTypeChunks(
                         ClusterObjectUtils.SORT.NONE);
                 List<MiningUserTypeChunk> miningUserTypeChunks = miningOperationChunk.getMiningUserTypeChunks(
                         ClusterObjectUtils.SORT.NONE);
 
-                if (searchMode.equals(RoleAnalysisSearchMode.JACCARD)) {
+                if (searchMode.equals(RoleAnalysisSearchModeType.JACCARD)) {
                     possibleBusinessRole = ExtractJaccard.businessRoleDetection(miningRoleTypeChunks, miningUserTypeChunks,
                             defaultMinFrequency,
                             defaultMaxFrequency,
@@ -367,7 +367,7 @@ public static List<IntersectionObject> loadDefaultIntersection(RoleAnalysisClust
                 elements.add(elementsArray.getString(i));
             }
             mergedIntersection.add(new IntersectionObject(points, metric, type, currentElements, totalElements,
-                    elements, RoleAnalysisSearchMode.INTERSECTION));
+                    elements, RoleAnalysisSearchModeType.INTERSECTION));
         }
 
         return mergedIntersection;

diff --git a/...m/evolveum/midpoint/gui/impl/page/admin/role/mining/algorithm/cluster/ClusterOptions.java b/...m/evolveum/midpoint/gui/impl/page/admin/role/mining/algorithm/cluster/ClusterOptions.java
@@ -11,8 +11,8 @@
 
 import com.evolveum.midpoint.gui.api.page.PageBase;
 import com.evolveum.midpoint.prism.query.ObjectFilter;
-import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisProcessMode;
-import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisSearchMode;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisProcessModeType;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisSearchModeType;
 
 public class ClusterOptions implements Serializable {
     private PageBase pageBase;
@@ -22,29 +22,29 @@ public class ClusterOptions implements Serializable {
     private String identifier;
     private ObjectFilter query;
     private int assignThreshold;
-    RoleAnalysisProcessMode mode;
-    RoleAnalysisSearchMode searchMode;
+    RoleAnalysisProcessModeType mode;
+    RoleAnalysisSearchModeType searchMode;
     String name;
     int defaultIntersectionSearch = 10;
     int defaultOccupancySearch = 10;
     double defaultMinFrequency = 0.4;
     double defaultMaxFrequency = 1;
     double defaultJaccardThreshold = 0.8;
 
-    public ClusterOptions(PageBase pageBase, RoleAnalysisProcessMode mode,RoleAnalysisSearchMode searchMode) {
+    public ClusterOptions(PageBase pageBase, RoleAnalysisProcessModeType mode,RoleAnalysisSearchModeType searchMode) {
         this.pageBase = pageBase;
         this.mode = mode;
         this.searchMode = searchMode;
         setDefaultOptions(mode);
     }
 
-    private void setDefaultOptions(RoleAnalysisProcessMode mode) {
-        if (mode.equals(RoleAnalysisProcessMode.ROLE)) {
+    private void setDefaultOptions(RoleAnalysisProcessModeType mode) {
+        if (mode.equals(RoleAnalysisProcessModeType.ROLE)) {
             this.similarity = 0.6;
             this.assignThreshold = 300;
             this.minIntersections = 10;
             this.minGroupSize = 2;
-        } else if (mode.equals(RoleAnalysisProcessMode.USER)) {
+        } else if (mode.equals(RoleAnalysisProcessModeType.USER)) {
             this.similarity = 0.8;
             this.assignThreshold = 10;
             this.minIntersections = 10;
@@ -108,11 +108,11 @@ public void setAssignThreshold(int assignThreshold) {
         this.assignThreshold = assignThreshold;
     }
 
-    public RoleAnalysisProcessMode getMode() {
+    public RoleAnalysisProcessModeType getMode() {
         return mode;
     }
 
-    public void setMode(RoleAnalysisProcessMode mode) {
+    public void setMode(RoleAnalysisProcessModeType mode) {
         this.mode = mode;
     }
 
@@ -156,11 +156,11 @@ public void setDefaultMaxFrequency(double defaultMaxFrequency) {
         this.defaultMaxFrequency = defaultMaxFrequency;
     }
 
-    public RoleAnalysisSearchMode getSearchMode() {
+    public RoleAnalysisSearchModeType getSearchMode() {
         return searchMode;
     }
 
-    public void setSearchMode(RoleAnalysisSearchMode searchMode) {
+    public void setSearchMode(RoleAnalysisSearchModeType searchMode) {
         this.searchMode = searchMode;
     }
 

diff --git a/...olveum/midpoint/gui/impl/page/admin/role/mining/algorithm/cluster/ClusteringExecutor.java b/...olveum/midpoint/gui/impl/page/admin/role/mining/algorithm/cluster/ClusteringExecutor.java
@@ -11,16 +11,16 @@
 
 import com.evolveum.midpoint.prism.PrismObject;
 import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisCluster;
-import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisProcessMode;
+import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleAnalysisProcessModeType;
 
 public class ClusteringExecutor {
 
     private Clusterable clusterable;
 
-    public ClusteringExecutor(RoleAnalysisProcessMode mode) {
-        if (mode.equals(RoleAnalysisProcessMode.USER)) {
+    public ClusteringExecutor(RoleAnalysisProcessModeType mode) {
+        if (mode.equals(RoleAnalysisProcessModeType.USER)) {
             this.clusterable = new UserBasedClustering();
-        } else if (mode.equals(RoleAnalysisProcessMode.ROLE)) {
+        } else if (mode.equals(RoleAnalysisProcessModeType.ROLE)) {
             this.clusterable = new RoleBasedClustering();
         }
     }