Implement mass addition of bib information

CHANGELOG.md

@@ -39,6 +39,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 functionality for mass addition of bibliographic information for multiple entries to the "Lookup" menu. [#372](https://github.com/JabRef/jabref/issues/372)
 
 ### 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/...")),
+    MASS_GET_BIBLIOGRAPHIC_DATA(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

@@ -52,6 +52,7 @@
 import org.jabref.gui.maintable.NewLibraryFromPdfActionOffline;
 import org.jabref.gui.maintable.NewLibraryFromPdfActionOnline;
 import org.jabref.gui.mergeentries.MergeEntriesAction;
+import org.jabref.gui.mergeentries.MultiEntryMergeWithFetchedDataAction;
 import org.jabref.gui.plaincitationparser.PlainCitationParserAction;
 import org.jabref.gui.preferences.GuiPreferences;
 import org.jabref.gui.preferences.ShowPreferencesAction;
@@ -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.MASS_GET_BIBLIOGRAPHIC_DATA,
+                        new MultiEntryMergeWithFetchedDataAction(
+                                frame::getCurrentLibraryTab,
+                                preferences,
+                                dialogService,
+                                stateManager,
+                                taskExecutor
+                        )
+                )
         );
 
         final MenuItem pushToApplicationMenuItem = factory.createMenuItem(pushToApplicationCommand.getAction(), pushToApplicationCommand);

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

@@ -1,25 +1,19 @@
+
 package org.jabref.gui.mergeentries;
 
 import java.util.Arrays;
-import java.util.Collections;
-import java.util.Comparator;
 import java.util.List;
 import java.util.Optional;
-import java.util.Set;
-import java.util.TreeSet;
 
 import javax.swing.undo.UndoManager;
 
 import org.jabref.gui.DialogService;
 import org.jabref.gui.preferences.GuiPreferences;
 import org.jabref.gui.undo.NamedCompound;
-import org.jabref.gui.undo.UndoableChangeType;
-import org.jabref.gui.undo.UndoableFieldChange;
 import org.jabref.logic.importer.EntryBasedFetcher;
-import org.jabref.logic.importer.FetcherClientException;
-import org.jabref.logic.importer.FetcherServerException;
 import org.jabref.logic.importer.IdBasedFetcher;
 import org.jabref.logic.importer.ImportCleanup;
+import org.jabref.logic.importer.MergeEntriesHelper;
 import org.jabref.logic.importer.WebFetcher;
 import org.jabref.logic.importer.WebFetchers;
 import org.jabref.logic.l10n.Localization;
@@ -28,22 +22,22 @@
 import org.jabref.model.database.BibDatabaseContext;
 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.field.StandardField;
-import org.jabref.model.entry.types.EntryType;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-/**
- * Class for fetching and merging bibliographic information
- */
 public class FetchAndMergeEntry {
 
-    // All identifiers listed here should also appear at {@link org.jabref.logic.importer.CompositeIdFetcher#performSearchById}
-    public static List<Field> SUPPORTED_FIELDS = Arrays.asList(StandardField.DOI, StandardField.EPRINT, StandardField.ISBN);
+
+    public static final List<Field> SUPPORTED_IDENTIFIER_FIELDS = Arrays.asList(StandardField.DOI, StandardField.EPRINT, StandardField.ISBN);
 
     private static final Logger LOGGER = LoggerFactory.getLogger(FetchAndMergeEntry.class);
+    private static final String ERROR_FETCHING = "Error while fetching from %0";
+    private static final String MERGE_ENTRY_WITH = "Merge entry with %0 information";
+    private static final String UPDATED_ENTRY = "Updated entry with info from %0";
+    private static final String CANCELED_MERGING = "Canceled merging entries";
+
     private final DialogService dialogService;
     private final UndoManager undoManager;
     private final BibDatabaseContext bibDatabaseContext;
@@ -63,124 +57,112 @@ public FetchAndMergeEntry(BibDatabaseContext bibDatabaseContext,
     }
 
     public void fetchAndMerge(BibEntry entry) {
-        fetchAndMerge(entry, SUPPORTED_FIELDS);
+        fetchAndMerge(entry, SUPPORTED_IDENTIFIER_FIELDS);
     }
 
     public void fetchAndMerge(BibEntry entry, Field field) {
-        fetchAndMerge(entry, Collections.singletonList(field));
+        fetchAndMerge(entry, List.of(field));
     }
 
     public void fetchAndMerge(BibEntry entry, List<Field> fields) {
-        for (Field field : fields) {
-            Optional<String> fieldContent = entry.getField(field);
-            if (fieldContent.isPresent()) {
-                Optional<IdBasedFetcher> fetcher = WebFetchers.getIdBasedFetcherForField(field, preferences.getImportFormatPreferences());
-                if (fetcher.isPresent()) {
-                    BackgroundTask.wrap(() -> fetcher.get().performSearchById(fieldContent.get()))
-                                  .onSuccess(fetchedEntry -> {
-                                      ImportCleanup cleanup = ImportCleanup.targeting(bibDatabaseContext.getMode(), preferences.getFieldPreferences());
-                                      String type = field.getDisplayName();
-                                      if (fetchedEntry.isPresent()) {
-                                          cleanup.doPostCleanup(fetchedEntry.get());
-                                          showMergeDialog(entry, fetchedEntry.get(), fetcher.get());
-                                      } else {
-                                          dialogService.notify(Localization.lang("Cannot get info based on given %0: %1", type, fieldContent.get()));
-                                      }
-                                  })
-                                  .onFailure(exception -> {
-                                      LOGGER.error("Error while fetching bibliographic information", exception);
-                                      if (exception instanceof FetcherClientException) {
-                                          dialogService.showInformationDialogAndWait(Localization.lang("Fetching information using %0", fetcher.get().getName()), Localization.lang("No data was found for the identifier"));
-                                      } else if (exception instanceof FetcherServerException) {
-                                          dialogService.showInformationDialogAndWait(Localization.lang("Fetching information using %0", fetcher.get().getName()), Localization.lang("Server not available"));
-                                      } else {
-                                          dialogService.showInformationDialogAndWait(Localization.lang("Fetching information using %0", fetcher.get().getName()), Localization.lang("Error occurred %0", exception.getMessage()));
-                                      }
-                                  })
-                                  .executeWith(taskExecutor);
-                }
-            } else {
-                dialogService.notify(Localization.lang("No %0 found", field.getDisplayName()));
-            }
-        }
+        fields.forEach(field -> fetchAndMergeEntry(entry, field));
+    }
+
+    private void fetchAndMergeEntry(BibEntry entry, Field field) {
+        entry.getField(field)
+             .flatMap(fieldContent -> WebFetchers.getIdBasedFetcherForField(field, preferences.getImportFormatPreferences()))
+             .ifPresent(fetcher -> executeFetchTask(fetcher, field, entry));
+    }
+
+    private void executeFetchTask(IdBasedFetcher fetcher, Field field, BibEntry entry) {
+        entry.getField(field).ifPresent(fieldContent ->
+                BackgroundTask.wrap(() -> fetcher.performSearchById(fieldContent))
+                              .onSuccess(fetchedEntry -> processFetchedEntry(fetchedEntry, entry, fetcher))
+                              .onFailure(exception -> handleFetchException(exception, fetcher))
+                              .executeWith(taskExecutor)
+        );
+    }
+
+    private void processFetchedEntry(Optional<BibEntry> fetchedEntry, BibEntry originalEntry, IdBasedFetcher fetcher) {
+        ImportCleanup cleanup = ImportCleanup.targeting(bibDatabaseContext.getMode(), preferences.getFieldPreferences());
+        fetchedEntry.ifPresentOrElse(
+                entry -> {
+                    cleanup.doPostCleanup(entry);
+                    showMergeDialog(originalEntry, entry, fetcher);
+                },
+                () -> notifyNoInfo(originalEntry)
+        );
+    }
+
+    private void notifyNoInfo(BibEntry entry) {
+        dialogService.notify(Localization.lang("Cannot get info based on given %0: %1",
+                entry.getType().getDisplayName(),
+                entry.getCitationKey().orElse("")));
+    }
+
+    private void handleFetchException(Exception exception, WebFetcher fetcher) {
+        LOGGER.error("Error while fetching bibliographic information", exception);
+        dialogService.showErrorDialogAndWait(
+                Localization.lang(ERROR_FETCHING, fetcher.getName()),
+                exception
+        );
     }
 
     private void showMergeDialog(BibEntry originalEntry, BibEntry fetchedEntry, WebFetcher fetcher) {
+        MergeEntriesDialog dialog = createMergeDialog(originalEntry, fetchedEntry, fetcher);
+        Optional<BibEntry> mergedEntry = dialogService.showCustomDialogAndWait(dialog)
+                                                      .map(EntriesMergeResult::mergedEntry);
+
+        mergedEntry.ifPresentOrElse(
+                entry -> processMergedEntry(originalEntry, entry, fetcher),
+                () -> notifyCanceledMerge(originalEntry)
+        );
+    }
+
+    private MergeEntriesDialog createMergeDialog(BibEntry originalEntry, BibEntry fetchedEntry, WebFetcher fetcher) {
         MergeEntriesDialog dialog = new MergeEntriesDialog(originalEntry, fetchedEntry, preferences);
-        dialog.setTitle(Localization.lang("Merge entry with %0 information", fetcher.getName()));
+        dialog.setTitle(Localization.lang(MERGE_ENTRY_WITH, fetcher.getName()));
         dialog.setLeftHeaderText(Localization.lang("Original entry"));
         dialog.setRightHeaderText(Localization.lang("Entry from %0", fetcher.getName()));
-        Optional<BibEntry> mergedEntry = dialogService.showCustomDialogAndWait(dialog).map(EntriesMergeResult::mergedEntry);
-
-        if (mergedEntry.isPresent()) {
-            NamedCompound ce = new NamedCompound(Localization.lang("Merge entry with %0 information", fetcher.getName()));
-
-            // Updated the original entry with the new fields
-            Set<Field> jointFields = new TreeSet<>(Comparator.comparing(Field::getName));
-            jointFields.addAll(mergedEntry.get().getFields());
-            Set<Field> originalFields = new TreeSet<>(Comparator.comparing(Field::getName));
-            originalFields.addAll(originalEntry.getFields());
-            boolean edited = false;
-
-            // entry type
-            EntryType oldType = originalEntry.getType();
-            EntryType newType = mergedEntry.get().getType();
-
-            if (!oldType.equals(newType)) {
-                originalEntry.setType(newType);
-                ce.addEdit(new UndoableChangeType(originalEntry, oldType, newType));
-                edited = true;
-            }
-
-            // fields
-            for (Field field : jointFields) {
-                Optional<String> originalString = originalEntry.getField(field);
-                Optional<String> mergedString = mergedEntry.get().getField(field);
-                if (originalString.isEmpty() || !originalString.equals(mergedString)) {
-                    originalEntry.setField(field, mergedString.get()); // mergedString always present
-                    ce.addEdit(new UndoableFieldChange(originalEntry, field, originalString.orElse(null),
-                            mergedString.get()));
-                    edited = true;
-                }
-            }
-
-            // Remove fields which are not in the merged entry, unless they are internal fields
-            for (Field field : originalFields) {
-                if (!jointFields.contains(field) && !FieldFactory.isInternalField(field)) {
-                    Optional<String> originalString = originalEntry.getField(field);
-                    originalEntry.clearField(field);
-                    ce.addEdit(new UndoableFieldChange(originalEntry, field, originalString.get(), null)); // originalString always present
-                    edited = true;
-                }
-            }
-
-            if (edited) {
-                ce.end();
-                undoManager.addEdit(ce);
-                dialogService.notify(Localization.lang("Updated entry with info from %0", fetcher.getName()));
-            } else {
-                dialogService.notify(Localization.lang("No information added"));
-            }
-        } else {
-            dialogService.notify(Localization.lang("Canceled merging entries"));
+        return dialog;
+    }
+
+    private void processMergedEntry(BibEntry originalEntry, BibEntry mergedEntry, WebFetcher fetcher) {
+        NamedCompound ce = new NamedCompound(Localization.lang(MERGE_ENTRY_WITH, fetcher.getName()));
+        MergeEntriesHelper.mergeEntries(originalEntry, mergedEntry, ce);
+
+        if (ce.hasEdits()) {
+            ce.end();
+            undoManager.addEdit(ce);
         }
+
+        dialogService.notify(Localization.lang(UPDATED_ENTRY, fetcher.getName()));
+    }
+
+    private void notifyCanceledMerge(BibEntry entry) {
+        String citationKey = entry.getCitationKey().orElse(entry.getAuthorTitleYear(40));
+        dialogService.notify(Localization.lang(CANCELED_MERGING) + " [" + citationKey + "]");
     }
 
     public void fetchAndMerge(BibEntry entry, EntryBasedFetcher fetcher) {
         BackgroundTask.wrap(() -> fetcher.performSearch(entry).stream().findFirst())
-                      .onSuccess(fetchedEntry -> {
-                          if (fetchedEntry.isPresent()) {
-                              ImportCleanup cleanup = ImportCleanup.targeting(bibDatabaseContext.getMode(), preferences.getFieldPreferences());
-                              cleanup.doPostCleanup(fetchedEntry.get());
-                              showMergeDialog(entry, fetchedEntry.get(), fetcher);
-                          } else {
-                              dialogService.notify(Localization.lang("Could not find any bibliographic information."));
-                          }
-                      })
-                      .onFailure(exception -> {
-                          LOGGER.error("Error while fetching entry with {} ", fetcher.getName(), exception);
-                          dialogService.showErrorDialogAndWait(Localization.lang("Error while fetching from %0", fetcher.getName()), exception);
-                      })
+                      .onSuccess(fetchedEntry -> processFetchedEntryForEntryBasedFetcher(fetchedEntry, entry, fetcher))
+                      .onFailure(exception -> handleFetchException(exception, fetcher))
                       .executeWith(taskExecutor);
     }
+
+    private void processFetchedEntryForEntryBasedFetcher(Optional<BibEntry> fetchedEntry, BibEntry originalEntry, EntryBasedFetcher fetcher) {
+        fetchedEntry
+                .map(this::cleanupFetchedEntry)
+                .ifPresentOrElse(
+                        fe -> showMergeDialog(originalEntry, fe, fetcher),
+                        () -> dialogService.notify(Localization.lang("Could not find any bibliographic information."))
+                );
+    }
+
+    private BibEntry cleanupFetchedEntry(BibEntry fetchedEntry) {
+        ImportCleanup cleanup = ImportCleanup.targeting(bibDatabaseContext.getMode(), preferences.getFieldPreferences());
+        cleanup.doPostCleanup(fetchedEntry);
+        return fetchedEntry;
+    }
 }

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

@@ -33,7 +33,7 @@ public MergeWithFetchedEntryAction(DialogService dialogService,
         this.undoManager = undoManager;
 
         this.executable.bind(ActionHelper.needsEntriesSelected(1, stateManager)
-                                         .and(ActionHelper.isAnyFieldSetForSelectedEntry(FetchAndMergeEntry.SUPPORTED_FIELDS, stateManager)));
+                                         .and(ActionHelper.isAnyFieldSetForSelectedEntry(FetchAndMergeEntry.SUPPORTED_IDENTIFIER_FIELDS, stateManager)));
     }
 
     @Override
@@ -49,6 +49,14 @@ public void execute() {
         }
 
         BibEntry originalEntry = stateManager.getSelectedEntries().getFirst();
-        new FetchAndMergeEntry(stateManager.getActiveDatabase().get(), taskExecutor, preferences, dialogService, undoManager).fetchAndMerge(originalEntry);
+        FetchAndMergeEntry fetchAndMergeEntry = new FetchAndMergeEntry(
+                stateManager.getActiveDatabase().get(),
+                taskExecutor,
+                preferences,
+                dialogService,
+                undoManager
+        );
+
+        fetchAndMergeEntry.fetchAndMerge(originalEntry);
     }
 }