cleanup configuration ui fixed and improved. added validation for mid…

…point version in configuration against maven version (dependencies)

studio-idea-plugin/src/main/java/com/evolveum/midpoint/studio/MidPointConstants.java

@@ -15,5 +15,5 @@ public interface MidPointConstants {
 
     String DEFAULT_MIDPOINT_VERSION = "4.8";
 
-    List<String> SUPPORTED_VERSIONS = List.of("4.4", "4.7", "4.8", "4.9");
+    List<String> SUPPORTED_VERSIONS = List.of("4.4", "4.5", "4.6", "4.7", "4.8", "4.9");
 }

studio-idea-plugin/src/main/java/com/evolveum/midpoint/studio/action/task/CleanupFileTask.java

@@ -89,7 +89,7 @@ private String cleanupObject(MidPointObject object) {
 
             List<PrismObject<? extends ObjectType>> result = (List) objects.stream().map(PrismObject::clone).toList();
 
-            CleanupService cleanupService = CleanupService.getInstance(getProject());
+            CleanupService cleanupService = CleanupService.get(getProject());
 
             CleanupActionProcessor processor = cleanupService.createCleanupProcessor();
             processor.setListener(new CleanupListener() {

studio-idea-plugin/src/main/java/com/evolveum/midpoint/studio/impl/configuration/CleanupConfiguration.java

@@ -6,6 +6,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
+import java.util.stream.Collectors;
 
 public class CleanupConfiguration implements Serializable {
 
@@ -17,6 +18,12 @@ public class CleanupConfiguration implements Serializable {
      */
     private CleanupPathActionConfiguration askActionOverride;
 
+    private boolean cleanupConnectorReferences;
+
+    private boolean replaceConnectorOidsWithFilter;
+
+    private boolean warnAboutMissingReferences;
+
     public @NotNull List<CleanupPathConfiguration> getCleanupPaths() {
         if (cleanupPaths == null) {
             cleanupPaths = new ArrayList<>();
@@ -36,16 +43,58 @@ public void setAskActionOverride(CleanupPathActionConfiguration askActionOverrid
         this.askActionOverride = askActionOverride;
     }
 
+    public boolean isCleanupConnectorReferences() {
+        return cleanupConnectorReferences;
+    }
+
+    public void setCleanupConnectorReferences(boolean cleanupConnectorReferences) {
+        this.cleanupConnectorReferences = cleanupConnectorReferences;
+    }
+
+    public boolean isReplaceConnectorOidsWithFilter() {
+        return replaceConnectorOidsWithFilter;
+    }
+
+    public void setReplaceConnectorOidsWithFilter(boolean replaceConnectorOidsWithFilter) {
+        this.replaceConnectorOidsWithFilter = replaceConnectorOidsWithFilter;
+    }
+
+    public boolean isWarnAboutMissingReferences() {
+        return warnAboutMissingReferences;
+    }
+
+    public void setWarnAboutMissingReferences(boolean warnAboutMissingReferences) {
+        this.warnAboutMissingReferences = warnAboutMissingReferences;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         CleanupConfiguration that = (CleanupConfiguration) o;
-        return Objects.equals(cleanupPaths, that.cleanupPaths) && askActionOverride == that.askActionOverride;
+        return cleanupConnectorReferences == that.cleanupConnectorReferences && replaceConnectorOidsWithFilter == that.replaceConnectorOidsWithFilter && warnAboutMissingReferences == that.warnAboutMissingReferences && Objects.equals(cleanupPaths, that.cleanupPaths) && askActionOverride == that.askActionOverride;
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(cleanupPaths, askActionOverride);
+        return Objects.hash(cleanupPaths, askActionOverride, cleanupConnectorReferences, replaceConnectorOidsWithFilter, warnAboutMissingReferences);
+    }
+
+    public void copyTo(@NotNull CleanupConfiguration configuration) {
+        configuration.setAskActionOverride(askActionOverride);
+
+        List paths = getCleanupPaths().stream().map(p -> p.copy()).collect(Collectors.toList());
+        configuration.setCleanupPaths(paths);
+
+        configuration.setCleanupConnectorReferences(cleanupConnectorReferences);
+        configuration.setReplaceConnectorOidsWithFilter(replaceConnectorOidsWithFilter);
+        configuration.setWarnAboutMissingReferences(warnAboutMissingReferences);
+    }
+
+    public CleanupConfiguration copy() {
+        CleanupConfiguration clone = new CleanupConfiguration();
+        copyTo(clone);
+
+        return clone;
     }
 }

studio-idea-plugin/src/main/java/com/evolveum/midpoint/studio/impl/configuration/CleanupService.java

@@ -20,7 +20,7 @@ public CleanupService(@NotNull Project project) {
         super(project, CleanupConfiguration.class);
     }
 
-    public static CleanupService getInstance(@NotNull Project project) {
+    public static CleanupService get(@NotNull Project project) {
         return project.getService(CleanupService.class);
     }
 

studio-idea-plugin/src/main/java/com/evolveum/midpoint/studio/util/MavenUtils.java

@@ -0,0 +1,20 @@
+package com.evolveum.midpoint.studio.util;
+
+import com.intellij.openapi.project.Project;
+import org.jetbrains.idea.maven.model.MavenArtifact;
+import org.jetbrains.idea.maven.project.MavenProjectsManager;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class MavenUtils {
+
+    public static Set<MavenArtifact> getMidpointDependencies(Project project) {
+        return MavenProjectsManager.getInstance(project).getProjects().stream()
+                .map(p -> p.getDependencies())
+                .flatMap(List::stream)
+                .filter(ma -> ma.getGroupId().startsWith("com.evolveum.midpoint") || ma.getGroupId().startsWith("com.evolveum.prism"))
+                .collect(Collectors.toSet());
+    }
+}

studio-idea-plugin/src/main/kotlin/com/evolveum/midpoint/studio/ui/configuration/CleanupConfigurable.kt

@@ -1,5 +1,6 @@
 package com.evolveum.midpoint.studio.ui.configuration
 
+import com.evolveum.midpoint.studio.impl.configuration.CleanupConfiguration
 import com.evolveum.midpoint.studio.impl.configuration.CleanupPathActionConfiguration
 import com.evolveum.midpoint.studio.impl.configuration.CleanupService
 import com.evolveum.midpoint.studio.util.StudioLocalization
@@ -10,88 +11,89 @@ import com.intellij.openapi.ui.DialogPanel
 import com.intellij.ui.SimpleListCellRenderer
 import com.intellij.ui.dsl.builder.Align
 import com.intellij.ui.dsl.builder.bindItem
+import com.intellij.ui.dsl.builder.bindSelected
 import com.intellij.ui.dsl.builder.panel
 import java.util.*
-import java.util.stream.Collectors
 
 class CleanupConfigurable(val project: Project) :
     BoundSearchableConfigurable(message("CleanupConfigurable.title"), "") {
 
-    private val cleanupPathsPanel = CleanupPathsPanel(project)
+    private var configuration: CleanupConfiguration = CleanupConfiguration()
 
-    private var askActionOverride: CleanupPathActionConfiguration? = null
+    private val cleanupPathsPanel = CleanupPathsPanel(project)
 
     override fun apply() {
         super.apply()
 
-        val list = cleanupPathsPanel.data
-
-        val service = CleanupService.getInstance(project)
-        val settings = service.settings
-
-        settings.cleanupPaths = list
-        settings.askActionOverride = askActionOverride
-
-        service.settingsUpdated()
+        val service = CleanupService.get(project)
+        service.settings = configuration
     }
 
     override fun isModified(): Boolean {
-        val service = CleanupService.getInstance(project)
-        val original = service.settings.cleanupPaths
-
-        return super.isModified() || !Objects.equals(original, cleanupPathsPanel.data)
+        val service = CleanupService.get(project)
+
+        return super.isModified() || !Objects.equals(configuration, service.settings)
     }
 
     override fun reset() {
-        val service = CleanupService.getInstance(project)
-        val settings = service.settings
-
-        val list = settings.cleanupPaths.stream()
-            .map { p -> p.copy() }
-            .collect(Collectors.toList())
+        val service = CleanupService.get(project)
+        configuration = service.settings.copy()
 
-        cleanupPathsPanel.data = list
-        askActionOverride = settings.askActionOverride
+        cleanupPathsPanel.data = configuration.cleanupPaths
 
         super.reset()
     }
 
     override fun createPanel(): DialogPanel {
         return panel {
-            row {
-                cell(cleanupPathsPanel)
-                    .align(Align.FILL)
-            }
-                .resizableRow()
-                .rowComment(message("CleanupConfigurable.cleanupPaths.comment"))
-            row(message("CleanupConfigurable.askActionOverride")) {
-                comboBox(
-                    listOf(
-                        null,
-                        CleanupPathActionConfiguration.IGNORE,
-                        CleanupPathActionConfiguration.REMOVE
-                    ),
-                    SimpleListCellRenderer.create(
-                        StudioLocalization.get().translate("CleanupConfigurable.nullGlobalAction")
-                    ) { StudioLocalization.get().translateEnum(it) }
-                )
-                    .bindItem(
-                        { askActionOverride },
-                        { askActionOverride = it }
+            groupRowsRange(message("CleanupConfigurable.paths")) {
+                row {
+                    cell(cleanupPathsPanel)
+                        .align(Align.FILL)
+                }
+                    .resizableRow()
+                    .rowComment(message("CleanupConfigurable.cleanupPaths.comment"))
+                row(message("CleanupConfigurable.askActionOverride")) {
+                    comboBox(
+                        listOf(
+                            null,
+                            CleanupPathActionConfiguration.IGNORE,
+                            CleanupPathActionConfiguration.REMOVE
+                        ),
+                        SimpleListCellRenderer.create(
+                            StudioLocalization.get().translate("CleanupConfigurable.nullGlobalAction")
+                        ) { StudioLocalization.get().translateEnum(it) }
                     )
+                        .bindItem(
+                            { configuration.askActionOverride },
+                            { configuration.askActionOverride = it }
+                        )
+                }
             }
             groupRowsRange(message("CleanupConfigurable.references")) {
-                row() {
+                row {
                     checkBox(message("CleanupConfigurable.cleanupConnectorReferences"))
                         .comment(message("CleanupConfigurable.cleanupConnectorReferences.comment"))
+                        .bindSelected(
+                            { configuration.isCleanupConnectorReferences },
+                            { configuration.isCleanupConnectorReferences = it }
+                        )
                 }
-                row() {
+                row {
                     checkBox(message("CleanupConfigurable.replaceConnectorReferences"))
                         .comment(message("CleanupConfigurable.replaceConnectorReferences.comment"))
+                        .bindSelected(
+                            { configuration.isReplaceConnectorOidsWithFilter },
+                            { configuration.isReplaceConnectorOidsWithFilter = it }
+                        )
                 }
-                row() {
+                row {
                     checkBox(message("CleanupConfigurable.warnAboutMissingOid"))
                         .comment(message("CleanupConfigurable.warnAboutMissingOid.comment"))
+                        .bindSelected(
+                            { configuration.isWarnAboutMissingReferences },
+                            { configuration.isWarnAboutMissingReferences = it }
+                        )
                 }
             }
         }

studio-idea-plugin/src/main/kotlin/com/evolveum/midpoint/studio/ui/configuration/MidPointConfigurable.kt

@@ -3,13 +3,17 @@ package com.evolveum.midpoint.studio.ui.configuration
 import com.evolveum.midpoint.studio.MidPointConstants
 import com.evolveum.midpoint.studio.impl.configuration.MidPointConfiguration
 import com.evolveum.midpoint.studio.impl.configuration.MidPointService
+import com.evolveum.midpoint.studio.util.MavenUtils
 import com.evolveum.midpoint.studio.util.StudioLocalization.message
 import com.intellij.openapi.options.BoundSearchableConfigurable
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.ui.ComboBox
 import com.intellij.openapi.ui.DialogPanel
+import com.intellij.openapi.ui.ValidationInfo
 import com.intellij.ui.SimpleListCellRenderer
 import com.intellij.ui.components.JBTextField
 import com.intellij.ui.dsl.builder.*
+import com.intellij.ui.layout.ValidationInfoBuilder
 import javax.swing.JComponent
 
 /**
@@ -60,6 +64,7 @@ open class MidPointConfigurable(val project: Project) :
                             { configuration.midpointVersion },
                             { configuration.midpointVersion = it })
                         .validationOnApply(::validateNotNull)
+                        .validationOnInput(::validateMidpointVersion)
                 }
                 row {
                     checkBox(message("MidPointConfigurable.updateOnUpload"))
@@ -134,4 +139,35 @@ open class MidPointConfigurable(val project: Project) :
             }
         }
     }
+
+    private fun validateMidpointVersion(builder: ValidationInfoBuilder, combo: ComboBox<String>): ValidationInfo? {
+        val version = combo.item
+
+        val dependencies = MavenUtils.getMidpointDependencies(project)
+        if (dependencies.isEmpty()) {
+            return builder.warning("No midpoint dependencies found in maven project.")
+        }
+
+        val versions = dependencies.stream()
+            .map { it.version }
+            .distinct()
+            .sorted()
+            .toList()
+
+        if (versions.size > 1) {
+            return builder.warning(
+                "Midpoint dependencies fount in maven project have different versions (" + versions.joinToString(
+                    ", "
+                ) + ")."
+            )
+        }
+
+        val mvnVersion = versions[0]
+
+        if (!mvnVersion.startsWith(version)) {
+            return builder.warning("Midpoint dependencies fount in maven project have different version (" + mvnVersion + ") than selected.")
+        }
+
+        return null
+    }
 }

studio-idea-plugin/src/main/resources/META-INF/plugin.xml

@@ -35,12 +35,6 @@
 
         <projectService serviceImplementation="com.evolveum.midpoint.studio.impl.trace.TraceService"/>
 
-        <projectConfigurable parentId="language"
-                             instance="com.evolveum.midpoint.studio.ui.MidPointProjectStructureConfigurable"
-                             id="com.evolveum.midpoint.studio.ui.MidPointProjectStructureConfigurable"
-                             displayName="MidPoint"
-                             nonDefaultProject="true"/>
-
         <projectConfigurable
                 parentId="language"
                 instance="com.evolveum.midpoint.studio.ui.configuration.MidPointConfigurable"

studio-idea-plugin/src/main/resources/messages/MidPointStudio.properties

@@ -72,3 +72,4 @@ CleanupConfigurable.replaceConnectorReferences=Replace connector oid references
 CleanupConfigurable.replaceConnectorReferences.comment=Cleanup will try to replace connector reference oid with search filter based on connector type/version in selected environment.
 CleanupConfigurable.warnAboutMissingOid=Warn about missing oid
 CleanupConfigurable.warnAboutMissingOid.comment=Cleanup will warn about references that points to objects not available in project locally.
+CleanupConfigurable.paths=Paths