cleanup task - missing references configuration, wip

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

@@ -11,7 +11,9 @@
 import com.evolveum.midpoint.studio.client.ClientUtils;
 import com.evolveum.midpoint.studio.client.MidPointObject;
 import com.evolveum.midpoint.studio.impl.*;
-import com.evolveum.midpoint.studio.impl.configuration.*;
+import com.evolveum.midpoint.studio.impl.configuration.CleanupService;
+import com.evolveum.midpoint.studio.impl.configuration.ObjectReferencesConfiguration;
+import com.evolveum.midpoint.studio.impl.configuration.ReferenceConfiguration;
 import com.evolveum.midpoint.studio.impl.psi.search.ObjectFileBasedIndexImpl;
 import com.evolveum.midpoint.studio.util.MavenUtils;
 import com.evolveum.midpoint.studio.util.MidPointUtils;
@@ -25,6 +27,7 @@
 import com.intellij.openapi.actionSystem.AnActionEvent;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.progress.ProgressIndicator;
 import com.intellij.openapi.ui.messages.MessageDialog;
 import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.vfs.VirtualFile;
@@ -50,6 +53,13 @@ public class CleanupFileTask extends ClientBackgroundableTask<TaskState> {
 
     private static final Logger LOG = Logger.getInstance(CleanupFileTask.class);
 
+    /**
+     * Summary of missing references for all objects (files) processed using this task.
+     * <p>
+     * Used for notification actions.
+     */
+    private List<ObjectReferencesConfiguration> missingReferencesSummary;
+
     public CleanupFileTask(@NotNull AnActionEvent event, Environment environment) {
         super(event.getProject(), TITLE, NOTIFICATION_KEY);
 
@@ -64,6 +74,15 @@ protected MidPointClient setupMidpointClient() {
         return new MidPointClient(getProject(), env, true, true);
     }
 
+    @Override
+    protected void doRun(ProgressIndicator indicator) {
+        missingReferencesSummary = new ArrayList<>();
+
+        super.doRun(indicator);
+
+        missingReferencesSummary.clear();
+    }
+
     @Override
     public ProcessObjectResult processObject(MidPointObject object) {
         String oldContent = object.getContent();
@@ -142,6 +161,12 @@ protected PrismObject<ConnectorType> resolveConnector(String oid) {
             for (PrismObject<? extends ObjectType> obj : result) {
                 CleanupResult cleanupResult = processor.process(obj, Source.of(object.getFile(), object.getContent()));
 
+                List<ObjectReferenceType> missingReferences = cleanupResult.getMissingReferences();
+                if (!missingReferences.isEmpty()) {
+                    missingReferencesSummary.add(
+                            buildObjectReferencesConfiguration(object.getOid(), object.getType(), missingReferences));
+                }
+
                 publishCleanupNotifications(object, cleanupResult);
             }
 
@@ -230,58 +255,57 @@ private void publishNotification(
 
         VirtualFile file = VirtualFileManager.getInstance().findFileByNioPath(object.getFile().toPath());
 
-        // filter ignored missing references based on project configuration (cleanup/missing settings)
-        List<ObjectReferenceType> downloadOnly = computeMissingOnly(object.getOid(), object.getType(), missingReferences);
-
         MidPointUtils.publishNotification(
-                getProject(), notificationKey, "Cleanup warning", msg, type,
-                createNotificationActions(file, object.getOid(), object.getType(), missingReferences, downloadOnly));
+                getProject(),
+                notificationKey,
+                "Cleanup warning",
+                msg,
+                type,
+                createNotificationActions(
+                        file,
+                        List.of(
+                                buildObjectReferencesConfiguration(object.getOid(), object.getType(), missingReferences)
+                        ),
+                        false
+                )
+        );
     }
 
-    private List<ObjectReferenceType> computeMissingOnly(
+    private ObjectReferencesConfiguration buildObjectReferencesConfiguration(
             String oid, ObjectTypes type, List<ObjectReferenceType> missingReferences) {
 
-        MissingReferencesConfiguration missingRefsConfig = CleanupService.get(getProject()).getSettings().getMissingReferences();
-        ObjectReferencesConfiguration objectRefsConfig = missingRefsConfig.getObjects().stream()
-                .filter(orc -> Objects.equals(oid, orc.getOid()))
-                .findFirst()
-                .orElse(null);
+        ObjectReferencesConfiguration config = new ObjectReferencesConfiguration();
+        config.setOid(oid);
+        config.setType(type.getTypeQName());
 
-        Map<String, ReferenceDecisionConfiguration> map = objectRefsConfig.getIgnoredReferences().stream()
-                .collect(Collectors.toMap(ReferenceConfiguration::getOid, o -> o.getDecision()));
+        for (ObjectReferenceType ref : missingReferences) {
+            ReferenceConfiguration rc = new ReferenceConfiguration();
+            rc.setOid(ref.getOid());
+            rc.setType(ref.getType());
 
-        // todo use this to filter existing files
-//        ObjectFileBasedIndexImpl.getVirtualFiles()
-
-        return missingReferences.stream()
-                .filter(o -> {
-                    if (objectRefsConfig == null
-                            || Objects.equals(missingRefsConfig.getDefaultDecision(), ReferenceDecisionConfiguration.ALWAYS)) {
-                        return true;
-                    }
-
-//                    map.get
-//                    return objectRefsConfig.getReferences().stream()
-//                            .noneMatch(orc -> Objects.equals(orc.getOid(), o.getOid()));
+            config.getReferences().add(rc);
+        }
 
-                    // todo implement
-                    return true;
-                })
-                .toList();
+        return config;
     }
 
+
     private NotificationAction[] createNotificationActions(
-            VirtualFile file, String oid, ObjectTypes type, List<ObjectReferenceType> missingReferences, List<ObjectReferenceType> downloadOnly) {
+            VirtualFile file, List<ObjectReferencesConfiguration> missingReferences, boolean summary) {
 
         List<NotificationAction> actions = new ArrayList<>();
         if (file != null) {
             actions.add(new SeeObjectNotificationAction(file));
         }
+
         if (!missingReferences.isEmpty()) {
-            actions.add(new MissingReferencesNotificationAction(oid, type, missingReferences));
+            actions.add(new MissingReferencesNotificationAction(missingReferences, summary));
         }
-        if (!downloadOnly.isEmpty()) {
-            actions.add(new DownloadMissingNotificationAction(downloadOnly));
+
+        DownloadMissingNotificationAction downloadAction =
+                new DownloadMissingNotificationAction(getProject(), missingReferences);
+        if (downloadAction.isVisible()) {
+            actions.add(downloadAction);
         }
 
         return actions.toArray(NotificationAction[]::new);
@@ -300,6 +324,6 @@ protected NotificationAction[] getNotificationActionsAfterFinish() {
         // todo fix this for whole cleanup - how to compute missing references and download only
         //  ...and oid/type if this is for all
 
-        return createNotificationActions(null, null, null, List.of(), List.of());
+        return createNotificationActions(null, missingReferencesSummary, true);
     }
 }

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

@@ -1,6 +1,7 @@
 package com.evolveum.midpoint.studio.impl;
 
-import com.evolveum.midpoint.studio.util.ActionUtils;
+import com.evolveum.midpoint.schema.constants.ObjectTypes;
+import com.evolveum.midpoint.studio.impl.configuration.*;
 import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectReferenceType;
 import com.intellij.notification.Notification;
 import com.intellij.notification.NotificationAction;
@@ -9,26 +10,81 @@
 import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
 
 public class DownloadMissingNotificationAction extends NotificationAction {
 
-    private List<ObjectReferenceType> references;
+    private static final String TEXT = "Download missing";
 
-    public DownloadMissingNotificationAction(@NotNull List<ObjectReferenceType> references) {
-        super("Download missing");
+    private final Project project;
 
-        this.references = references;
+    private final List<ObjectReferencesConfiguration> data;
+
+    public DownloadMissingNotificationAction(
+            @NotNull Project project, @NotNull List<ObjectReferencesConfiguration> data) {
+        super(TEXT);
+
+        this.project = project;
+        this.data = data;
+
+
+        // filter ignored missing references based on project configuration (cleanup/missing settings)
+//        List<ObjectReferenceType> downloadOnly = computeDownloadOnly(object.getOid(), object.getType(), missingReferences);
+//
+//        List<ObjectReferenceType> downloadOnly = List.of(); // todo implement
+//        if (!downloadOnly.isEmpty()) {
+//            actions.add(new DownloadMissingNotificationAction(downloadOnly));
+//        }
     }
 
     @Override
     public void actionPerformed(AnActionEvent e, Notification notification) {
         Project project = e.getProject();
 
-        ActionUtils.runDownloadTask(project, references, false);
+// todo implement
+        //        ActionUtils.runDownloadTask(project, references, false);
     }
 
     @Override
     public boolean isDumbAware() {
         return true;
     }
+
+    public boolean isVisible() {
+        return true;// todo implement
+    }
+
+    private List<ObjectReferenceType> computeDownloadOnly(
+            String oid, ObjectTypes type, List<ObjectReferenceType> missingReferences) {
+
+        MissingReferencesConfiguration missingRefsConfig = CleanupService.get(project).getSettings().getMissingReferences();
+        ObjectReferencesConfiguration objectRefsConfig = missingRefsConfig.getObjects().stream()
+                .filter(orc -> Objects.equals(oid, orc.getOid()))
+                .findFirst()
+                .orElse(null);
+
+        Map<String, ReferenceDecisionConfiguration> map = objectRefsConfig.getReferences().stream()
+                .collect(Collectors.toMap(ReferenceConfiguration::getOid, o -> o.getDecision()));
+
+        // todo use this to filter existing files
+//        ObjectFileBasedIndexImpl.getVirtualFiles()
+
+        return missingReferences.stream()
+                .filter(o -> {
+                    if (objectRefsConfig == null
+                            || Objects.equals(missingRefsConfig.getDefaultDecision(), ReferenceDecisionConfiguration.ALWAYS)) {
+                        return true;
+                    }
+
+//                    map.get
+//                    return objectRefsConfig.getReferences().stream()
+//                            .noneMatch(orc -> Objects.equals(orc.getOid(), o.getOid()));
+
+                    // todo implement
+                    return true;
+                })
+                .toList();
+    }
 }

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

@@ -1,38 +1,42 @@
 package com.evolveum.midpoint.studio.impl;
 
-import com.evolveum.midpoint.schema.constants.ObjectTypes;
 import com.evolveum.midpoint.studio.impl.configuration.ObjectReferencesConfiguration;
 import com.evolveum.midpoint.studio.ui.cleanup.MissingObjectRefsDialog;
+import com.evolveum.midpoint.studio.ui.configuration.MissingReferencesConfigurable;
 import com.evolveum.midpoint.studio.util.ActionUtils;
 import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectReferenceType;
 import com.intellij.notification.Notification;
 import com.intellij.notification.NotificationAction;
 import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.options.ShowSettingsUtil;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
 
 public class MissingReferencesNotificationAction extends NotificationAction {
 
-    private static final String TEXT = "Configure missing ...";
+    private static final String TEXT = "Configure missing...";
 
-    private final List<ObjectReferenceType> data = null;
+    private final List<ObjectReferencesConfiguration> data;
 
-    public MissingReferencesNotificationAction() {
-        super(TEXT);
-    }
+    private final boolean summary;
 
-    public MissingReferencesNotificationAction(@NotNull String oid, @NotNull ObjectTypes type, @NotNull List<ObjectReferenceType> data) {
+    public MissingReferencesNotificationAction(@NotNull List<ObjectReferencesConfiguration> data, boolean summary) {
         super(TEXT);
 
-//        this.data = data;
+        this.data = data;
+        this.summary = summary;
     }
 
     @Override
     public void actionPerformed(AnActionEvent e, Notification notification) {
         Project project = e.getProject();
 
+        if (summary) {
+            ShowSettingsUtil.getInstance().showSettingsDialog(project, MissingReferencesConfigurable.class);
+            return;
+        }
 
         // todo get settings and pass proper configuration part to dialog
 

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

@@ -20,7 +20,7 @@ public class ObjectReferencesConfiguration implements Serializable, Comparable<O
     @OptionTag(tag = "type", nameAttribute = "", converter = QNameConverter.class)
     private QName type;
 
-    private List<ReferenceConfiguration> ignoredReferences;
+    private List<ReferenceConfiguration> references;
 
     public String getOid() {
         return oid;
@@ -38,15 +38,15 @@ public void setType(QName type) {
         this.type = type;
     }
 
-    public List<ReferenceConfiguration> getIgnoredReferences() {
-        if (ignoredReferences == null) {
-            ignoredReferences = new ArrayList<>();
+    public List<ReferenceConfiguration> getReferences() {
+        if (references == null) {
+            references = new ArrayList<>();
         }
-        return ignoredReferences;
+        return references;
     }
 
-    public void setIgnoredReferences(List<ReferenceConfiguration> ignoredReferences) {
-        this.ignoredReferences = ignoredReferences;
+    public void setReferences(List<ReferenceConfiguration> references) {
+        this.references = references;
     }
 
     @Override
@@ -56,12 +56,12 @@ public boolean equals(Object o) {
         ObjectReferencesConfiguration that = (ObjectReferencesConfiguration) o;
         return Objects.equals(oid, that.oid)
                 && Objects.equals(type, that.type)
-                && Objects.equals(ignoredReferences, that.ignoredReferences);
+                && Objects.equals(references, that.references);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(oid, type, ignoredReferences);
+        return Objects.hash(oid, type, references);
     }
 
     @Override
@@ -81,10 +81,10 @@ public ObjectReferencesConfiguration copy() {
         copy.setOid(oid);
         copy.setType(type);
 
-        List<ReferenceConfiguration> paths = getIgnoredReferences().stream()
+        List<ReferenceConfiguration> paths = getReferences().stream()
                 .map(ReferenceConfiguration::copy)
                 .toList();
-        copy.setIgnoredReferences(paths);
+        copy.setReferences(paths);
 
         return copy;
     }