Implement mass addition of bib information (Closes #372)

CHANGELOG.md

@@ -44,6 +44,7 @@ Note that this project **does not** adhere to [Semantic Versioning](https://semv
 - We added support to automatically open a `.bib` file in the current/parent folder if no other library is opened. [koppor#377](https://github.com/koppor/jabref/issues/377)
 - We added a search bar for filtering keyboard shortcuts. [#11686](https://github.com/JabRef/jabref/issues/11686)
 - By double clicking on a local citation in the Citation Relations Tab you can now jump the linked entry. [#11955](https://github.com/JabRef/jabref/pull/11955)
+- Added batch fetching of bibliographic data for multiple entries in the "Lookup" menu. [koppor#372](https://github.com/koppor/jabref/issues/372)
 - We use the menu icon for background tasks as a progress indicator to visualise an import's progress when dragging and dropping several PDF files into the main table. [#12072](https://github.com/JabRef/jabref/pull/12072)
 
 ### Changed

src/main/java/org/jabref/gui/actions/StandardActions.java

@@ -37,6 +37,7 @@ public enum StandardActions implements Action {
     OPEN_URL(Localization.lang("Open URL or DOI"), IconTheme.JabRefIcons.WWW, KeyBinding.OPEN_URL_OR_DOI),
     SEARCH_SHORTSCIENCE(Localization.lang("Search ShortScience")),
     MERGE_WITH_FETCHED_ENTRY(Localization.lang("Get bibliographic data from %0", "DOI/ISBN/...")),
+    BATCH_MERGE_WITH_FETCHED_ENTRY(Localization.lang("Get bibliographic data from %0 (fully automated)", "DOI/ISBN/...")),
     ATTACH_FILE(Localization.lang("Attach file"), IconTheme.JabRefIcons.ATTACH_FILE),
     ATTACH_FILE_FROM_URL(Localization.lang("Attach file from URL"), IconTheme.JabRefIcons.DOWNLOAD_FILE),
     PRIORITY(Localization.lang("Priority"), IconTheme.JabRefIcons.PRIORITY),

src/main/java/org/jabref/gui/frame/MainMenu.java

@@ -51,7 +51,9 @@
 import org.jabref.gui.linkedfile.RedownloadMissingFilesAction;
 import org.jabref.gui.maintable.NewLibraryFromPdfActionOffline;
 import org.jabref.gui.maintable.NewLibraryFromPdfActionOnline;
+import org.jabref.gui.mergeentries.BatchEntryMergeWithFetchedDataAction;
 import org.jabref.gui.mergeentries.MergeEntriesAction;
+import org.jabref.gui.mergeentries.MergeWithFetchedEntryAction;
 import org.jabref.gui.plaincitationparser.PlainCitationParserAction;
 import org.jabref.gui.preferences.GuiPreferences;
 import org.jabref.gui.preferences.ShowPreferencesAction;
@@ -273,7 +275,19 @@ private void createMenu() {
 
                 new SeparatorMenuItem(),
 
-                factory.createMenuItem(StandardActions.FIND_UNLINKED_FILES, new FindUnlinkedFilesAction(dialogService, stateManager))
+                factory.createMenuItem(StandardActions.FIND_UNLINKED_FILES, new FindUnlinkedFilesAction(dialogService, stateManager)),
+
+                new SeparatorMenuItem(),
+
+                factory.createMenuItem(
+                        StandardActions.MERGE_WITH_FETCHED_ENTRY,
+                        new MergeWithFetchedEntryAction(dialogService, stateManager, taskExecutor, preferences, undoManager)),
+
+                new SeparatorMenuItem(),
+
+                factory.createMenuItem(
+                        StandardActions.BATCH_MERGE_WITH_FETCHED_ENTRY,
+                        new BatchEntryMergeWithFetchedDataAction(stateManager, undoManager, preferences, dialogService, taskExecutor))
         );
 
         final MenuItem pushToApplicationMenuItem = factory.createMenuItem(pushToApplicationCommand.getAction(), pushToApplicationCommand);

src/main/java/org/jabref/gui/maintable/RightClickMenu.java

@@ -21,9 +21,7 @@
 import org.jabref.gui.keyboard.KeyBindingRepository;
 import org.jabref.gui.linkedfile.AttachFileAction;
 import org.jabref.gui.linkedfile.AttachFileFromURLAction;
-import org.jabref.gui.menus.ChangeEntryTypeMenu;
 import org.jabref.gui.mergeentries.MergeEntriesAction;
-import org.jabref.gui.mergeentries.MergeWithFetchedEntryAction;
 import org.jabref.gui.preferences.GuiPreferences;
 import org.jabref.gui.preview.CopyCitationAction;
 import org.jabref.gui.preview.PreviewPreferences;
@@ -87,12 +85,7 @@ public static ContextMenu create(BibEntryTableViewModel entry,
                 extractFileReferencesOffline,
 
                 factory.createMenuItem(StandardActions.OPEN_URL, new OpenUrlAction(dialogService, stateManager, preferences)),
-                factory.createMenuItem(StandardActions.SEARCH_SHORTSCIENCE, new SearchShortScienceAction(dialogService, stateManager, preferences)),
-
-                new SeparatorMenuItem(),
-
-                new ChangeEntryTypeMenu(libraryTab.getSelectedEntries(), libraryTab.getBibDatabaseContext(), undoManager, entryTypesManager).asSubMenu(),
-                factory.createMenuItem(StandardActions.MERGE_WITH_FETCHED_ENTRY, new MergeWithFetchedEntryAction(dialogService, stateManager, taskExecutor, preferences, undoManager))
+                factory.createMenuItem(StandardActions.SEARCH_SHORTSCIENCE, new SearchShortScienceAction(dialogService, stateManager, preferences))
         );
 
         EasyBind.subscribe(preferences.getGrobidPreferences().grobidEnabledProperty(), enabled -> {

src/main/java/org/jabref/gui/mergeentries/BatchEntryMergeTask.java

@@ -0,0 +1,153 @@
+package org.jabref.gui.mergeentries;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
+
+import javax.swing.undo.UndoManager;
+
+import org.jabref.gui.undo.NamedCompound;
+import org.jabref.logic.importer.fetcher.MergingIdBasedFetcher;
+import org.jabref.logic.l10n.Localization;
+import org.jabref.logic.util.BackgroundTask;
+import org.jabref.logic.util.NotificationService;
+import org.jabref.model.entry.BibEntry;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * A background task that handles fetching and merging of bibliography entries.
+ * This implementation provides improved concurrency handling, better Optional usage,
+ * and more robust error handling.
+ */
+public class BatchEntryMergeTask extends BackgroundTask<List<String>> {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(BatchEntryMergeTask.class);
+    private final MergeContext context;
+    private final NamedCompound compoundEdit;
+    private final AtomicInteger processedEntries;
+    private final AtomicInteger successfulUpdates;
+
+    public BatchEntryMergeTask(MergeContext context) {
+        this.context = context;
+        this.compoundEdit = new NamedCompound(Localization.lang("Merge entries"));
+        this.processedEntries = new AtomicInteger(0);
+        this.successfulUpdates = new AtomicInteger(0);
+
+        configureTask();
+    }
+
+    private void configureTask() {
+        setTitle(Localization.lang("Fetching and merging entry(s)"));
+        withInitialMessage(Localization.lang("Starting merge operation..."));
+        showToUser(true);
+    }
+
+    @Override
+    public List<String> call() throws Exception {
+        try {
+            List<String> updatedEntries = processMergeEntries();
+            finalizeOperation(updatedEntries);
+            LOGGER.debug("Merge operation completed. Processed: {}, Successfully updated: {}",
+                    processedEntries.get(), successfulUpdates.get());
+            notifySuccess(successfulUpdates.get());
+            return updatedEntries;
+        } catch (Exception e) {
+            LOGGER.error("Critical error during merge operation", e);
+            notifyError(e);
+            throw e;
+        }
+    }
+
+    private List<String> processMergeEntries() {
+        return context.entries().stream()
+                      .takeWhile(_ -> !isCancelled())
+                      .map(this::processSingleEntryWithProgress)
+                      .filter(Optional::isPresent)
+                      .map(Optional::get)
+                      .collect(Collectors.toList());
+    }
+
+    private Optional<String> processSingleEntryWithProgress(BibEntry entry) {
+        updateProgress(processedEntries.incrementAndGet(), context.entries().size());
+        updateMessage(Localization.lang("Processing entry %0 of %1",
+                processedEntries.get(),
+                context.entries().size()));
+        return processSingleEntry(entry);
+    }
+
+    private Optional<String> processSingleEntry(BibEntry entry) {
+        try {
+            LOGGER.debug("Processing entry: {}", entry);
+            return context.fetcher().fetchEntry(entry)
+                          .filter(MergingIdBasedFetcher.FetcherResult::hasChanges)
+                          .flatMap(result -> {
+                              boolean changesApplied = applyMerge(entry, result);
+                              if (changesApplied) {
+                                  successfulUpdates.incrementAndGet();
+                                  return entry.getCitationKey();
+                              }
+                              return Optional.empty();
+                          });
+        } catch (Exception e) {
+            handleEntryProcessingError(entry, e);
+            return Optional.empty();
+        }
+    }
+
+    private boolean applyMerge(BibEntry entry, MergingIdBasedFetcher.FetcherResult result) {
+        synchronized (compoundEdit) {
+            try {
+                return MergeEntriesHelper.mergeEntries(result.mergedEntry(), entry, compoundEdit);
+            } catch (Exception e) {
+                LOGGER.error("Error during merge operation for entry: {}", entry, e);
+                return false;
+            }
+        }
+    }
+
+    private void handleEntryProcessingError(BibEntry entry, Exception e) {
+        String citationKey = entry.getCitationKey().orElse("unknown");
+        String message = Localization.lang("Error processing entry", citationKey, e.getMessage());
+        LOGGER.error(message, e);
+        context.notificationService().notify(message);
+    }
+
+    private void finalizeOperation(List<String> updatedEntries) {
+        if (!updatedEntries.isEmpty()) {
+            synchronized (compoundEdit) {
+                compoundEdit.end();
+                context.undoManager.addEdit(compoundEdit);
+            }
+        }
+    }
+
+    private void notifySuccess(int updateCount) {
+        String message = updateCount == 0
+                ? Localization.lang("No updates found.")
+                : Localization.lang("Batch update successful. %0 entry(s) updated.", updateCount);
+        context.notificationService().notify(message);
+    }
+
+    private void notifyError(Exception e) {
+        context.notificationService().notify(
+                Localization.lang("Merge operation failed: %0", e.getMessage()));
+    }
+
+    /**
+     * Record containing all the context needed for the merge operation.
+     * Implements defensive copying to ensure immutability.
+     */
+    public record MergeContext(
+            List<BibEntry> entries,
+            MergingIdBasedFetcher fetcher,
+            UndoManager undoManager,
+            NotificationService notificationService
+    ) {
+        public MergeContext {
+            entries = List.copyOf(entries); // Defensive copy
+        }
+    }
+}

src/main/java/org/jabref/gui/mergeentries/BatchEntryMergeWithFetchedDataAction.java

@@ -0,0 +1,67 @@
+package org.jabref.gui.mergeentries;
+
+import java.util.List;
+
+import javax.swing.undo.UndoManager;
+
+import org.jabref.gui.StateManager;
+import org.jabref.gui.actions.ActionHelper;
+import org.jabref.gui.actions.SimpleCommand;
+import org.jabref.gui.preferences.GuiPreferences;
+import org.jabref.logic.importer.fetcher.MergingIdBasedFetcher;
+import org.jabref.logic.l10n.Localization;
+import org.jabref.logic.util.NotificationService;
+import org.jabref.logic.util.TaskExecutor;
+import org.jabref.model.database.BibDatabaseContext;
+import org.jabref.model.entry.BibEntry;
+
+/**
+ * Handles batch merging of bibliography entries with fetched data.
+ */
+public class BatchEntryMergeWithFetchedDataAction extends SimpleCommand {
+
+    private final StateManager stateManager;
+    private final UndoManager undoManager;
+    private final GuiPreferences preferences;
+    private final NotificationService notificationService;
+    private final TaskExecutor taskExecutor;
+
+    public BatchEntryMergeWithFetchedDataAction(StateManager stateManager,
+                                                UndoManager undoManager,
+                                                GuiPreferences preferences,
+                                                NotificationService notificationService,
+                                                TaskExecutor taskExecutor) {
+        this.stateManager = stateManager;
+        this.undoManager = undoManager;
+        this.preferences = preferences;
+        this.notificationService = notificationService;
+        this.taskExecutor = taskExecutor;
+
+        this.executable.bind(ActionHelper.needsDatabase(stateManager));
+    }
+
+    @Override
+    public void execute() {
+        if (stateManager.getActiveDatabase().isEmpty()) {
+            return;
+        }
+
+        List<BibEntry> entries = stateManager.getActiveDatabase()
+                                             .map(BibDatabaseContext::getEntries)
+                                             .orElse(List.of());
+
+        if (entries.isEmpty()) {
+            notificationService.notify(Localization.lang("No entries available for merging"));
+            return;
+        }
+
+        MergingIdBasedFetcher fetcher = new MergingIdBasedFetcher(preferences.getImportFormatPreferences());
+        BatchEntryMergeTask mergeTask = new BatchEntryMergeTask(
+                new BatchEntryMergeTask.MergeContext(entries,
+                        fetcher,
+                        undoManager,
+                        notificationService));
+
+        mergeTask.executeWith(taskExecutor);
+    }
+}