JabRef-Zotero Compatibility - C (Insert jabref-entrytype into meta.xml)

jabgui/src/main/java/org/jabref/gui/openoffice/OOBibBase.java

@@ -15,6 +15,7 @@
 import org.jabref.logic.JabRefException;
 import org.jabref.logic.citationstyle.CitationStyle;
 import org.jabref.logic.l10n.Localization;
+import org.jabref.logic.openoffice.CitationEntryTypeMetadataManager;
 import org.jabref.logic.openoffice.OpenOfficePreferences;
 import org.jabref.logic.openoffice.action.EditInsert;
 import org.jabref.logic.openoffice.action.EditMerge;
@@ -47,6 +48,8 @@
 import org.jabref.model.openoffice.util.OOVoidResult;
 
 import com.airhacks.afterburner.injection.Injector;
+import com.sun.star.beans.IllegalTypeException;
+import com.sun.star.beans.PropertyVetoException;
 import com.sun.star.comp.helper.BootstrapException;
 import com.sun.star.container.NoSuchElementException;
 import com.sun.star.lang.WrappedTargetException;
@@ -92,12 +95,22 @@ public void guiActionSelectDocument(boolean autoSelectForSingle) throws WrappedT
         testDialog(connection.selectDocument(autoSelectForSingle));
 
         if (isConnectedToDocument()) {
-            initializeCitationAdapter(this.getXTextDocument().get());
+            XTextDocument doc = this.getXTextDocument().get();
+            initializeCitationAdapter(doc);
+            storeZoteroEntryTypes(doc);
             dialogService.notify(Localization.lang("Connected to document") + ": "
                     + this.getCurrentDocumentTitle().orElse(""));
         }
     }
 
+    private void storeZoteroEntryTypes(XTextDocument doc) {
+        try {
+            CitationEntryTypeMetadataManager.storeZoteroEntryTypes(doc);
+        } catch (IllegalTypeException | NoDocumentException | PropertyVetoException | WrappedTargetException e) {
+            LOGGER.warn("Could not store Zotero citation entry type metadata", e);
+        }
+    }
+
     /// A simple test for document availability.
     ///
     /// See also `isDocumentConnectionMissing` for a test actually attempting to use the connection.

jablib/src/main/java/org/jabref/logic/openoffice/CitationEntryTypeMetadata.java

@@ -0,0 +1,32 @@
+package org.jabref.logic.openoffice;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
+
+@NullMarked
+class CitationEntryTypeMetadata {
+
+    static final int SCHEMA_VERSION = 1;
+
+    int schemaVersion = SCHEMA_VERSION;
+    @Nullable Map<String, @Nullable CitationEntryType> citationTypeMap = new LinkedHashMap<>();
+
+    static class CitationEntryType {
+        @Nullable String jabrefEntryType;
+
+        CitationEntryType(String jabrefEntryType) {
+            this.jabrefEntryType = jabrefEntryType;
+        }
+    }
+
+    public static Map<String, @Nullable CitationEntryType> getCitationTypeMap(CitationEntryTypeMetadata metadata) {
+        Map<String, @Nullable CitationEntryType> citationTypeMap = Optional.ofNullable(metadata.citationTypeMap)
+                                                                           .orElseGet(LinkedHashMap::new);
+        metadata.citationTypeMap = citationTypeMap;
+        return citationTypeMap;
+    }
+}

jablib/src/main/java/org/jabref/logic/openoffice/CitationEntryTypeMetadataManager.java

@@ -0,0 +1,137 @@
+package org.jabref.logic.openoffice;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import org.jabref.logic.openoffice.CitationEntryTypeMetadata.CitationEntryType;
+import org.jabref.logic.util.strings.StringUtil;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.types.EntryTypeFactory;
+import org.jabref.model.openoffice.uno.NoDocumentException;
+import org.jabref.model.openoffice.uno.UnoReferenceMark;
+import org.jabref.model.openoffice.uno.UnoUserDefinedProperty;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonParseException;
+import com.sun.star.beans.IllegalTypeException;
+import com.sun.star.beans.PropertyVetoException;
+import com.sun.star.lang.WrappedTargetException;
+import com.sun.star.text.XTextDocument;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.jabref.logic.openoffice.CitationEntryTypeMetadata.getCitationTypeMap;
+
+@NullMarked
+public class CitationEntryTypeMetadataManager {
+
+    static final String PROPERTY_NAME = "jabref-entrytype";
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(CitationEntryTypeMetadataManager.class);
+    private static final Gson GSON = new Gson();
+
+    private CitationEntryTypeMetadataManager() {
+    }
+
+    public static void storeZoteroEntryTypes(XTextDocument document)
+            throws
+            IllegalTypeException,
+            NoDocumentException,
+            PropertyVetoException,
+            WrappedTargetException {
+        Map<String, String> entryTypesInMetaData = UnoUserDefinedProperty.getStringValue(document, PROPERTY_NAME)
+                                                                         .map(CitationEntryTypeMetadataManager::readEntryTypes)
+                                                                         .orElseGet(Map::of);
+        List<BibEntry> entries = parseZoteroEntries(UnoReferenceMark.getListOfNames(document), entryTypesInMetaData);
+        storeEntryTypes(document, entries);
+    }
+
+    public static void storeEntryTypes(XTextDocument document, List<BibEntry> entries)
+            throws
+            IllegalTypeException,
+            PropertyVetoException,
+            WrappedTargetException {
+        if (entries.isEmpty()) {
+            return;
+        }
+
+        Optional<String> existingMetadata = UnoUserDefinedProperty.getStringValue(document, PROPERTY_NAME);
+        String metadata = mergeEntryTypes(existingMetadata, entries);
+        UnoUserDefinedProperty.setStringProperty(document, PROPERTY_NAME, metadata);
+    }
+
+    static String mergeEntryTypes(Optional<String> existingMetadata, List<BibEntry> entries) {
+        CitationEntryTypeMetadata metadata = existingMetadata
+                .flatMap(CitationEntryTypeMetadataManager::parseMetadata)
+                .orElseGet(CitationEntryTypeMetadata::new);
+
+        Map<String, @Nullable CitationEntryType> citationTypeMap = getCitationTypeMap(metadata);
+        metadata.schemaVersion = CitationEntryTypeMetadata.SCHEMA_VERSION;
+
+        for (BibEntry entry : entries) {
+            entry.getCitationKey()
+                 .ifPresent(citationKey -> citationTypeMap.put(
+                         citationKey,
+                         new CitationEntryType(entry.getType().getName())));
+        }
+
+        return GSON.toJson(metadata);
+    }
+
+    static Map<String, String> readEntryTypes(String metadata) {
+        Optional<CitationEntryTypeMetadata> parsedMetadata = parseMetadata(metadata);
+        if (parsedMetadata.isEmpty()) {
+            return Map.of();
+        }
+
+        CitationEntryTypeMetadata entryTypeMetadata = parsedMetadata.get();
+        Map<String, @Nullable CitationEntryType> citationTypeMap = getCitationTypeMap(entryTypeMetadata);
+        Map<String, String> result = new LinkedHashMap<>(citationTypeMap.size());
+        for (Map.Entry<String, @Nullable CitationEntryType> entry : citationTypeMap.entrySet()) {
+            Optional.ofNullable(entry.getValue())
+                    .map(citationEntryType -> citationEntryType.jabrefEntryType)
+                    .filter(value -> !StringUtil.isBlank(value))
+                    .ifPresent(value -> result.put(entry.getKey(), value));
+        }
+        return result;
+    }
+
+    static List<BibEntry> parseZoteroEntries(List<String> referenceMarkNames, Map<String, String> entryTypesInMetaData) {
+        List<BibEntry> entries = new ArrayList<>();
+        for (String referenceMarkName : referenceMarkNames) {
+            if (ReferenceMark.isZoteroReferenceMarkName(referenceMarkName)) {
+                for (BibEntry entry : ZoteroCitationMarkParser.parse(referenceMarkName)) {
+                    applyStoredEntryType(entry, entryTypesInMetaData);
+                    entries.add(entry);
+                }
+            }
+        }
+        return entries;
+    }
+
+    private static void applyStoredEntryType(BibEntry entry, Map<String, String> entryTypesByCitationKey) {
+        entry.getCitationKey()
+             .map(entryTypesByCitationKey::get)
+             .filter(entryType -> !StringUtil.isBlank(entryType))
+             .map(EntryTypeFactory::parse)
+             .ifPresent(entry::setType);
+    }
+
+    private static Optional<CitationEntryTypeMetadata> parseMetadata(String metadata) {
+        if (StringUtil.isBlank(metadata)) {
+            return Optional.empty();
+        }
+
+        try {
+            return Optional.of(GSON.fromJson(metadata, CitationEntryTypeMetadata.class));
+        } catch (JsonParseException e) {
+            LOGGER.debug("Could not parse citation entry type metadata", e);
+            return Optional.empty();
+        }
+    }
+}

jablib/src/main/java/org/jabref/logic/openoffice/oocsltext/CSLCitationOOAdapter.java

@@ -13,6 +13,7 @@
 import org.jabref.logic.citationstyle.CitationStyle;
 import org.jabref.logic.citationstyle.CitationStyleGenerator;
 import org.jabref.logic.citationstyle.CitationStyleOutputFormat;
+import org.jabref.logic.openoffice.CitationEntryTypeMetadataManager;
 import org.jabref.logic.openoffice.OpenOfficePreferences;
 import org.jabref.logic.openoffice.style.OOStyle;
 import org.jabref.model.database.BibDatabase;
@@ -220,6 +221,7 @@ private void insertReferences(XTextCursor cursor, List<BibEntry> entries, OOText
             }
         }
         markManager.insertReferenceIntoOO(entries, document, cursor, ooText, !preceedingSpaceExists, openOfficePreferences.getAddSpaceAfter(), citationType);
+        CitationEntryTypeMetadataManager.storeEntryTypes(document, entries);
         markManager.setRealTimeNumberUpdateRequired(isNumericStyle);
         markManager.readAndUpdateExistingMarks();
         this.citationType = markManager.getCitationType();
@@ -269,6 +271,7 @@ private void updateAllCitationsWithNewStyle(CitationStyle style, CSLCitationType
                                                .flatMap(db -> db.getEntries().stream())
                                                .filter(this::isCitedEntry)
                                                .toList();
+        CitationEntryTypeMetadataManager.storeEntryTypes(document, citedEntries);
 
         BibDatabase unifiedDatabase = new BibDatabase(citedEntries);
         BibDatabaseContext unifiedBibDatabaseContext = new BibDatabaseContext(unifiedDatabase);

jablib/src/test/java/org/jabref/logic/openoffice/CitationEntryTypeMetadataTest.java

@@ -0,0 +1,116 @@
+package org.jabref.logic.openoffice;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.field.StandardField;
+import org.jabref.model.entry.types.StandardEntryType;
+
+import org.jspecify.annotations.NullMarked;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@NullMarked
+class CitationEntryTypeMetadataTest {
+
+    private static final String ZOTERO_JOURNAL_ARTICLE = """
+            ZOTERO_ITEM CSL_CITATION {
+              "citationItems": [
+                {
+                  "id": 587,
+                  "itemData": {
+                    "type": "article-journal",
+                    "title": "Test article",
+                    "container-title": "Journal of Test"
+                  }
+                }
+              ]
+            } test1234
+            """;
+
+    @Test
+    void mergeEntryTypesStoresCitationKeyAndEntryType() {
+        BibEntry entry = new BibEntry(StandardEntryType.Article)
+                .withCitationKey("Keen2020");
+
+        String metadata = CitationEntryTypeMetadataManager.mergeEntryTypes(Optional.empty(), List.of(entry));
+
+        assertEquals(Map.of("Keen2020", "article"), CitationEntryTypeMetadataManager.readEntryTypes(metadata));
+    }
+
+    @Test
+    void mergeEntryTypesKeepsExistingEntryTypes() {
+        BibEntry entry = new BibEntry(StandardEntryType.InProceedings)
+                .withCitationKey("Smith2021");
+        String existingMetadata = """
+                {
+                  "schemaVersion": 1,
+                  "citationTypeMap": {
+                    "Keen2020": {
+                      "jabrefEntryType": "article"
+                    }
+                  }
+                }
+                """;
+
+        String metadata = CitationEntryTypeMetadataManager.mergeEntryTypes(Optional.of(existingMetadata), List.of(entry));
+
+        assertEquals(Map.of(
+                "Keen2020", "article",
+                "Smith2021", "inproceedings"), CitationEntryTypeMetadataManager.readEntryTypes(metadata));
+    }
+
+    @Test
+    void mergeEntryTypesUpdatesExistingCitationKey() {
+        BibEntry entry = new BibEntry(StandardEntryType.Book)
+                .withCitationKey("Keen2020");
+        String existingMetadata = """
+                {
+                  "schemaVersion": 1,
+                  "citationTypeMap": {
+                    "Keen2020": {
+                      "jabrefEntryType": "article"
+                    }
+                  }
+                }
+                """;
+
+        String metadata = CitationEntryTypeMetadataManager.mergeEntryTypes(Optional.of(existingMetadata), List.of(entry));
+
+        assertEquals(Map.of("Keen2020", "book"), CitationEntryTypeMetadataManager.readEntryTypes(metadata));
+    }
+
+    @Test
+    void readEntryTypesReturnsEmptyMapForInvalidMetadata() {
+        assertEquals(Map.of(), CitationEntryTypeMetadataManager.readEntryTypes("not json"));
+    }
+
+    @Test
+    void parseZoteroEntriesUsesCslToJabRefMapping() {
+        List<BibEntry> entries = CitationEntryTypeMetadataManager.parseZoteroEntries(
+                List.of("JR_cite_1_Keen2020", ZOTERO_JOURNAL_ARTICLE),
+                Map.of());
+        BibEntry expectedEntry = new BibEntry(StandardEntryType.Article)
+                .withCitationKey("Zotero-587")
+                .withField(StandardField.TITLE, "Test article")
+                .withField(StandardField.JOURNALTITLE, "Journal of Test");
+
+        assertEquals(List.of(expectedEntry), entries);
+    }
+
+    @Test
+    void parseZoteroEntriesUsesStoredEntryTypeMetadata() {
+        List<BibEntry> entries = CitationEntryTypeMetadataManager.parseZoteroEntries(
+                List.of(ZOTERO_JOURNAL_ARTICLE),
+                Map.of("Zotero-587", "book"));
+        BibEntry expectedEntry = new BibEntry(StandardEntryType.Book)
+                .withCitationKey("Zotero-587")
+                .withField(StandardField.TITLE, "Test article")
+                .withField(StandardField.JOURNALTITLE, "Journal of Test");
+
+        assertEquals(List.of(expectedEntry), entries);
+    }
+}