Implement mass addition of bib information (Closes #372)

CHANGELOG.md

@@ -43,6 +43,7 @@ Note that this project **does not** adhere to [Semantic Versioning](https://semv
 - We added automatic browser extension install on Windows for Chrome and Edge. [#6076](https://github.com/JabRef/jabref/issues/6076)
 - 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,6 +51,7 @@
 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.plaincitationparser.PlainCitationParserAction;
 import org.jabref.gui.preferences.GuiPreferences;
@@ -273,7 +274,20 @@ 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.BATCH_MERGE_WITH_FETCHED_ENTRY,
+                        new BatchEntryMergeWithFetchedDataAction(
+                                frame::getCurrentLibraryTab,
+                                preferences,
+                                dialogService,
+                                stateManager,
+                                taskExecutor
+                        )
+                )
         );
 
         final MenuItem pushToApplicationMenuItem = factory.createMenuItem(pushToApplicationCommand.getAction(), pushToApplicationCommand);

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

@@ -0,0 +1,176 @@
+package org.jabref.gui.mergeentries;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Supplier;
+
+import javafx.application.Platform;
+
+import org.jabref.gui.LibraryTab;
+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.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.logic.util.TaskExecutor;
+import org.jabref.model.entry.BibEntry;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Handles the merging of multiple bibliography entries with fetched data.
+ * This action performs background fetching and merging of entries while
+ * providing progress updates to the user.
+ */
+public class BatchEntryMergeWithFetchedDataAction extends SimpleCommand {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(BatchEntryMergeWithFetchedDataAction.class);
+
+    private final Supplier<LibraryTab> tabSupplier;
+    private final GuiPreferences preferences;
+    private final NotificationService notificationService;
+    private final TaskExecutor taskExecutor;
+
+    public BatchEntryMergeWithFetchedDataAction(Supplier<LibraryTab> tabSupplier,
+                                                GuiPreferences preferences,
+                                                NotificationService notificationService,
+                                                StateManager stateManager,
+                                                TaskExecutor taskExecutor) {
+        this.tabSupplier = tabSupplier;
+        this.preferences = preferences;
+        this.notificationService = notificationService;
+        this.taskExecutor = taskExecutor;
+        this.executable.bind(ActionHelper.needsDatabase(stateManager));
+    }
+
+    @Override
+    public void execute() {
+        LibraryTab libraryTab = tabSupplier.get();
+        if (libraryTab == null) {
+            LOGGER.error("Cannot perform batch merge: no library is open.");
+            return;
+        }
+
+        List<BibEntry> libraryEntries = libraryTab.getDatabase().getEntries();
+        if (libraryEntries.isEmpty()) {
+            notificationService.notify(Localization.lang("empty library"));
+            return;
+        }
+
+        MergeContext context = new MergeContext(
+                libraryTab,
+                libraryEntries,
+                new MergingIdBasedFetcher(preferences.getImportFormatPreferences()),
+                notificationService
+        );
+
+        taskExecutor.execute(createBackgroundTask(context));
+    }
+
+    private static BackgroundTask<List<String>> createBackgroundTask(MergeContext context) {
+        BackgroundTask<List<String>> task = new BackgroundTask<>() {
+            @Override
+            public List<String> call() {
+                return processMergeEntries(context, this);
+            }
+        };
+
+        task.setTitle(Localization.lang("Fetching and merging entries"));
+        task.showToUser(true);
+
+        task.onSuccess(updatedEntries ->
+                handleSuccess(updatedEntries, context));
+
+        task.onFailure(ex ->
+                handleFailure(ex, context.notificationService()));
+
+        return task;
+    }
+
+    private static List<String> processMergeEntries(MergeContext context, BackgroundTask<?> task) {
+        int totalEntries = context.entries().size();
+
+        for (int i = 0; i < totalEntries && !task.isCancelled(); i++) {
+            BibEntry libraryEntry = context.entries().get(i);
+            updateProgress(i, totalEntries, task);
+            fetchAndMergeEntry(context, libraryEntry);
+        }
+
+        finalizeCompoundEdit(context);
+        return context.updatedEntries();
+    }
+
+    private static void fetchAndMergeEntry(MergeContext context, BibEntry libraryEntry) {
+        LOGGER.debug("Processing library entry: {}", libraryEntry);
+
+        context.fetcher().fetchEntry(libraryEntry)
+               .filter(MergingIdBasedFetcher.FetcherResult::hasChanges)
+               .ifPresent(result -> Platform.runLater(() -> {
+                   MergeEntriesHelper.mergeEntries(result.mergedEntry(), libraryEntry, context.compoundEdit());
+                   libraryEntry.getCitationKey().ifPresent(context.updatedEntries()::add);
+               }));
+    }
+
+    private static void finalizeCompoundEdit(MergeContext context) {
+        if (!context.updatedEntries().isEmpty()) {
+            Platform.runLater(() -> {
+                context.compoundEdit().end();
+                context.libraryTab().getUndoManager().addEdit(context.compoundEdit());
+            });
+        }
+    }
+
+    private static void updateProgress(int currentIndex, int totalEntries, BackgroundTask<?> task) {
+        Platform.runLater(() -> {
+            task.updateMessage(Localization.lang("Processing entry %0 of %1", currentIndex + 1, totalEntries));
+            task.updateProgress(currentIndex, totalEntries);
+        });
+    }
+
+    private static void handleSuccess(List<String> updatedEntries, MergeContext context) {
+        Platform.runLater(() -> {
+            String message = updatedEntries.isEmpty()
+                    ? Localization.lang("No updates found.")
+                    : Localization.lang("Batch update successful. %0 entries updated.",
+                    updatedEntries.size());
+
+            LOGGER.debug("Batch update completed. {}", message);
+            context.notificationService().notify(message);
+        });
+    }
+
+    private static void handleFailure(Exception ex, NotificationService notificationService) {
+        LOGGER.error("Error during fetch and merge", ex);
+        Platform.runLater(() ->
+                notificationService.notify(
+                        Localization.lang("Error while fetching and merging entries: %0", ex.getMessage())
+                )
+        );
+    }
+
+    private record MergeContext(
+            LibraryTab libraryTab,
+            List<BibEntry> entries,
+            MergingIdBasedFetcher fetcher,
+            NamedCompound compoundEdit,
+            List<String> updatedEntries,
+            NotificationService notificationService
+    ) {
+        MergeContext(LibraryTab libraryTab, List<BibEntry> entries, MergingIdBasedFetcher fetcher, NotificationService notificationService) {
+            this(
+                    libraryTab,
+                    entries,
+                    fetcher,
+                    new NamedCompound(Localization.lang("Merge entries")),
+                    Collections.synchronizedList(new ArrayList<>()),
+                    notificationService
+            );
+        }
+    }
+}

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

@@ -0,0 +1,102 @@
+package org.jabref.gui.mergeentries;
+
+import java.util.LinkedHashSet;
+import java.util.Optional;
+import java.util.Set;
+
+import org.jabref.gui.undo.NamedCompound;
+import org.jabref.gui.undo.UndoableChangeType;
+import org.jabref.gui.undo.UndoableFieldChange;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.field.Field;
+import org.jabref.model.entry.field.FieldFactory;
+import org.jabref.model.entry.types.EntryType;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Helper class for merging bibliography entries with undo support.
+ * Source entry data is merged into the library entry, with longer field values preferred
+ * and obsolete fields removed.
+ */
+public final class MergeEntriesHelper {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(MergeEntriesHelper.class);
+
+    private MergeEntriesHelper() {
+    }
+
+    /**
+     * Merges two BibEntry objects with undo support.
+     *
+     * @param entryFromFetcher The entry containing new information (source, from the fetcher)
+     * @param entryFromLibrary The entry to be updated (target, from the library)
+     * @param undoManager Compound edit to collect undo information
+     */
+    public static void mergeEntries(BibEntry entryFromFetcher, BibEntry entryFromLibrary, NamedCompound undoManager) {
+        LOGGER.debug("Entry from fetcher: {}", entryFromFetcher);
+        LOGGER.debug("Entry from library: {}", entryFromLibrary);
+
+        mergeEntryType(entryFromFetcher, entryFromLibrary, undoManager);
+        mergeFields(entryFromFetcher, entryFromLibrary, undoManager);
+        removeFieldsNotPresentInFetcher(entryFromFetcher, entryFromLibrary, undoManager);
+    }
+
+    private static void mergeEntryType(BibEntry entryFromFetcher, BibEntry entryFromLibrary, NamedCompound undoManager) {
+        EntryType fetcherType = entryFromFetcher.getType();
+        EntryType libraryType = entryFromLibrary.getType();
+
+        if (!libraryType.equals(fetcherType)) {
+            LOGGER.debug("Updating type {} -> {}", libraryType, fetcherType);
+            entryFromLibrary.setType(fetcherType);
+            undoManager.addEdit(new UndoableChangeType(entryFromLibrary, libraryType, fetcherType));
+        }
+    }
+
+    private static void mergeFields(BibEntry entryFromFetcher, BibEntry entryFromLibrary, NamedCompound undoManager) {
+        Set<Field> allFields = new LinkedHashSet<>();
+        allFields.addAll(entryFromFetcher.getFields());
+        allFields.addAll(entryFromLibrary.getFields());
+
+        for (Field field : allFields) {
+            Optional<String> fetcherValue = entryFromFetcher.getField(field);
+            Optional<String> libraryValue = entryFromLibrary.getField(field);
+
+            fetcherValue.ifPresent(newValue -> {
+                if (shouldUpdateField(newValue, libraryValue)) {
+                    LOGGER.debug("Updating field {}: {} -> {}", field, libraryValue.orElse(null), newValue);
+                    entryFromLibrary.setField(field, newValue);
+                    undoManager.addEdit(new UndoableFieldChange(entryFromLibrary, field, libraryValue.orElse(null), newValue));
+                }
+            });
+        }
+    }
+
+    private static boolean shouldUpdateField(String fetcherValue, Optional<String> libraryValue) {
+        return libraryValue.map(value -> fetcherValue.length() > value.length())
+                           .orElse(true);
+    }
+
+    /**
+     * Removes fields from the library entry that are not present in the fetcher entry.
+     * This ensures the merged entry only contains fields that are considered current
+     * according to the fetched data.
+     */
+    private static void removeFieldsNotPresentInFetcher(BibEntry entryFromFetcher, BibEntry entryFromLibrary, NamedCompound undoManager) {
+        Set<Field> obsoleteFields = new LinkedHashSet<>(entryFromLibrary.getFields());
+        obsoleteFields.removeAll(entryFromFetcher.getFields());
+
+        for (Field field : obsoleteFields) {
+            if (FieldFactory.isInternalField(field)) {
+                continue;
+            }
+
+            entryFromLibrary.getField(field).ifPresent(value -> {
+                LOGGER.debug("Removing obsolete field {} with value {}", field, value);
+                entryFromLibrary.clearField(field);
+                undoManager.addEdit(new UndoableFieldChange(entryFromLibrary, field, value, null));
+            });
+        }
+    }
+}

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

@@ -1,3 +1,4 @@
+
 package org.jabref.gui.mergeentries;
 
 import javax.swing.undo.UndoManager;