Push selected publications to orcid

dspace-api/src/main/java/org/dspace/content/ItemServiceImpl.java

@@ -2151,7 +2151,7 @@ private void createOrcidQueueRecordsToDeleteOnOrcid(Context context, Item entity
 
         Map<Item, String> profileAndPutCodeMap = orcidHistoryService.findLastPutCodes(context, entity);
         for (Item profile : profileAndPutCodeMap.keySet()) {
-            if (orcidSynchronizationService.isSynchronizationAllowed(profile, entity)) {
+            if (orcidSynchronizationService.isSynchronizationAllowed(context, profile, entity)) {
                 String putCode = profileAndPutCodeMap.get(profile);
                 String title = getMetadataFirstValue(entity, "dc", "title", null, Item.ANY);
                 orcidQueueService.createEntityDeletionRecord(context, profile, title, entityType, putCode);

dspace-api/src/main/java/org/dspace/orcid/consumer/OrcidQueueConsumer.java

@@ -36,6 +36,7 @@
 import org.dspace.event.Event;
 import org.dspace.orcid.OrcidHistory;
 import org.dspace.orcid.OrcidOperation;
+import org.dspace.orcid.OrcidQueue;
 import org.dspace.orcid.factory.OrcidServiceFactory;
 import org.dspace.orcid.model.OrcidEntityType;
 import org.dspace.orcid.model.factory.OrcidProfileSectionFactory;
@@ -170,7 +171,20 @@ private void consumeEntity(Context context, Item entity) throws SQLException {
                 continue;
             }
 
-            if (shouldNotBeSynchronized(relatedItem, entity) || isAlreadyQueued(context, relatedItem, entity)) {
+            if (shouldNotBeSynchronized(context, relatedItem, entity) ||
+                isAlreadyQueued(context, relatedItem, entity)) {
+                // delete queue entries which are queued and relate on relationships,
+                // but where the relation does not exist anymore.
+                // Using the shouldNotBySynchonized might not be actual, because the solr
+                // might be behind the database state
+                if (isAlreadyQueued(context, relatedItem, entity)
+                    && isSyncSettingsBasedOnRelationshipCriteriaNotValid(context, relatedItem, entity)) {
+                    List<OrcidQueue> queueentries =
+                            orcidQueueService.findByProfileItemAndEntity(context, relatedItem, entity);
+                    for (OrcidQueue queueentry : queueentries) {
+                        orcidQueueService.delete(context, queueentry);
+                    }
+                }
                 continue;
             }
 
@@ -305,8 +319,14 @@ private boolean hasNotOrcidAccessToken(Context context, Item profileItemItem) {
         return orcidTokenService.findByProfileItem(context, profileItemItem) == null;
     }
 
-    private boolean shouldNotBeSynchronized(Item profileItem, Item entity) {
-        return !orcidSynchronizationService.isSynchronizationAllowed(profileItem, entity);
+    private boolean shouldNotBeSynchronized(Context context, Item profileItem, Item entity) {
+        return !orcidSynchronizationService.isSynchronizationAllowed(context, profileItem, entity);
+    }
+
+    private boolean isSyncSettingsBasedOnRelationshipCriteriaNotValid(
+        Context context, Item profileItem, Item entity) {
+        return orcidSynchronizationService.
+            isSyncSettingsBasedOnRelationshipCriteriaNotValid(context, profileItem, entity);
     }
 
     private boolean isNotProfileItem(Item profileItemItem) {

dspace-api/src/main/java/org/dspace/orcid/service/OrcidSynchronizationService.java

@@ -22,7 +22,7 @@
 import org.dspace.profile.OrcidSynchronizationMode;
 
 /**
- * Service that handle the the syncronization between a DSpace profile and the
+ * Service that handle the syncronization between a DSpace profile and the
  * relative ORCID profile, if any.
  *
  * @author Luca Giamminonni (luca.giamminonni at 4science.it)
@@ -117,10 +117,10 @@ public boolean setSynchronizationMode(Context context, Item profile, OrcidSynchr
      *
      * @param  profile the researcher profile item
      * @param  item    the entity type to check
-     * @return         true if the given entity type can be synchronize with ORCID,
+     * @return         true if the given entity type can be synchronized with ORCID,
      *                 false otherwise
      */
-    public boolean isSynchronizationAllowed(Item profile, Item item);
+    public boolean isSynchronizationAllowed(Context context, Item profile, Item item);
 
     /**
      * Returns the ORCID synchronization mode configured for the given profile item.
@@ -130,6 +130,18 @@ public boolean setSynchronizationMode(Context context, Item profile, OrcidSynchr
      */
     Optional<OrcidSynchronizationMode> getSynchronizationMode(Item profile);
 
+    /**
+     * Check if the current sync setting for the items is related to some relationship.
+     * And if so than check if the relationship criteria is not valid.
+     *
+     * @param  profile the researcher profile item
+     * @param  item    the entity type to check
+     * @return         true if the given entity type is bases on relationship
+     *                 false otherwise
+     */
+    boolean isSyncSettingsBasedOnRelationshipCriteriaNotValid(Context context, Item profile, Item item);
+
+
     /**
      * Returns the ORCID synchronization preference related to the given entity type
      * configured for the given profile item.

dspace-api/src/main/java/org/dspace/orcid/service/impl/OrcidQueueServiceImpl.java

@@ -8,6 +8,9 @@
 package org.dspace.orcid.service.impl;
 
 import static org.apache.commons.lang3.ArrayUtils.contains;
+import static org.dspace.profile.OrcidEntitySyncPreference.DISABLED;
+import static org.dspace.profile.OrcidEntitySyncPreference.MINE;
+import static org.dspace.profile.OrcidEntitySyncPreference.MY_SELECTED;
 
 import java.sql.SQLException;
 import java.util.Collections;
@@ -220,9 +223,27 @@ public void recalculateOrcidQueue(Context context, Item profileItem, OrcidEntity
         OrcidEntitySyncPreference preference) throws SQLException {
 
         String entityType = orcidEntityType.getEntityType();
-        if (preference == OrcidEntitySyncPreference.DISABLED) {
+        if (preference == DISABLED) {
             deleteByProfileItemAndRecordType(context, profileItem, entityType);
+        } else if (preference == MY_SELECTED || preference == MINE) {
+            // delete existing queue
+            deleteByProfileItemAndRecordType(context, profileItem, entityType);
+            // add additional filterquery
+            String relationname =
+                configurationService.getProperty("orcid.relation." + entityType + "." + preference.name());
+            boolean exclusion = configurationService.getBooleanProperty("orcid.relation."
+                + entityType + "." + preference.name() + ".exclusion", false);
+            if (StringUtils.isBlank(relationname)) {
+                return;
+            }
+            Iterator<Item> entities;
+            entities = findAllRelationShipEntitiesLinkableWith(context, profileItem, entityType, relationname,
+                exclusion);
+            while (entities.hasNext()) {
+                create(context, profileItem, entities.next());
+            }
         } else {
+            deleteByProfileItemAndRecordType(context, profileItem, entityType);
             Iterator<Item> entities = findAllEntitiesLinkableWith(context, profileItem, entityType);
             while (entities.hasNext()) {
                 create(context, profileItem, entities.next());
@@ -254,6 +275,40 @@ private Iterator<Item> findAllEntitiesLinkableWith(Context context, Item owner,
 
     }
 
+    private Iterator<Item> findAllRelationShipEntitiesLinkableWith(
+        Context context, Item owner, String entityType, String filterrelationname, boolean exclusion) {
+
+        String ownerType = itemService.getEntityType(owner);
+
+        String query = choiceAuthorityService.getAuthorityControlledFieldsByEntityType(ownerType).stream()
+                .map(metadataField -> metadataField.replaceAll("_", "."))
+                .filter(metadataField -> shouldNotBeIgnoredForOrcid(metadataField))
+                .map(metadataField -> metadataField + "_allauthority: \"" + owner.getID().toString() + "\"")
+                .collect(Collectors.joining(" OR "));
+
+        if (StringUtils.isEmpty(query)) {
+            return Collections.emptyIterator();
+        }
+
+        StringBuilder sb = new StringBuilder();
+        if (exclusion) {
+            sb.append("-");
+        }
+        sb.append("relation." + filterrelationname + ":");
+        sb.append(owner.getID().toString());
+
+        DiscoverQuery discoverQuery = new DiscoverQuery();
+        discoverQuery.addDSpaceObjectFilter(IndexableItem.TYPE);
+        discoverQuery.addFilterQueries(query);
+        discoverQuery.addFilterQueries("search.entitytype:" + entityType);
+
+        discoverQuery.addFilterQueries(sb.toString());
+
+        return new DiscoverResultItemIterator(context, discoverQuery);
+
+    }
+
+
     private boolean shouldNotBeIgnoredForOrcid(String metadataField) {
         return !contains(configurationService.getArrayProperty("orcid.linkable-metadata-fields.ignore"), metadataField);
     }

dspace-api/src/main/java/org/dspace/orcid/service/impl/OrcidSynchronizationServiceImpl.java

@@ -15,7 +15,6 @@
 import static org.apache.commons.lang3.EnumUtils.isValidEnum;
 import static org.apache.commons.lang3.StringUtils.isBlank;
 import static org.dspace.content.Item.ANY;
-import static org.dspace.profile.OrcidEntitySyncPreference.DISABLED;
 
 import java.sql.SQLException;
 import java.util.HashSet;
@@ -30,6 +29,7 @@
 import org.dspace.content.Item;
 import org.dspace.content.MetadataValue;
 import org.dspace.content.service.ItemService;
+import org.dspace.content.service.RelationshipService;
 import org.dspace.core.Context;
 import org.dspace.discovery.DiscoverQuery;
 import org.dspace.discovery.DiscoverResultItemIterator;
@@ -81,6 +81,9 @@ public class OrcidSynchronizationServiceImpl implements OrcidSynchronizationServ
     @Autowired
     private ResearcherProfileService researcherProfileService;
 
+    @Autowired
+    private RelationshipService relationshipService;
+
     @Override
     public void linkProfile(Context context, Item profile, OrcidTokenResponseDTO token) throws SQLException {
 
@@ -181,7 +184,7 @@ public boolean setSynchronizationMode(Context context, Item profile, OrcidSynchr
     }
 
     @Override
-    public boolean isSynchronizationAllowed(Item profile, Item item) {
+    public boolean isSynchronizationAllowed(Context context, Item profile, Item item) {
 
         if (isOrcidSynchronizationDisabled()) {
             return false;
@@ -193,9 +196,41 @@ public boolean isSynchronizationAllowed(Item profile, Item item) {
         }
 
         if (OrcidEntityType.isValidEntityType(entityType)) {
-            return getEntityPreference(profile, OrcidEntityType.fromEntityType(entityType))
-                .filter(pref -> pref != DISABLED)
-                .isPresent();
+            Optional<OrcidEntitySyncPreference> option;
+            option = getEntityPreference(profile, OrcidEntityType.fromEntityType(entityType));
+            if (option.isPresent()) {
+                try {
+                    switch (option.get()) {
+                        case DISABLED:
+                            return false;
+                        case ALL:
+                            return true;
+                        case MINE:
+                        case MY_SELECTED:
+                            String relationname = configurationService.getProperty("orcid.relation." + entityType + "."
+                                + option.get().name());
+                            if (isBlank(relationname)) {
+                                return false;
+                            }
+                            if (configurationService.getBooleanProperty("orcid.relation." + entityType + "."
+                                + option.get().name() + ".exclusion", false)) {
+                                //check if no relationship exists between profile and item (e.g. MINE)
+                                return relationShipMatchForOrcidSync(context, profile, item, relationname, false);
+                            } else {
+                                //check, if any relationship exists between profile and item(e.g. MY_SELECTED)
+
+                                return relationShipMatchForOrcidSync(context, profile, item, relationname, true);
+
+                            }
+                        default:
+                            return false;
+                    }
+                } catch (SQLException e) {
+                    throw new RuntimeException(e);
+                }
+            } else {
+                return false;
+            }
         }
 
         if (entityType.equals(researcherProfileService.getProfileType())) {
@@ -206,6 +241,58 @@ public boolean isSynchronizationAllowed(Item profile, Item item) {
 
     }
 
+    @Override
+    public boolean isSyncSettingsBasedOnRelationshipCriteriaNotValid(Context context, Item profile, Item item) {
+        String entityType = itemService.getEntityTypeLabel(item);
+        if (entityType == null) {
+            return false;
+        }
+        Optional<OrcidEntitySyncPreference> option =
+            getEntityPreference(profile, OrcidEntityType.fromEntityType(entityType));
+        if (option.isPresent()) {
+            try {
+                switch (option.get()) {
+                    case MINE:
+                    case MY_SELECTED:
+                        String relationname = configurationService.getProperty("orcid.relation." + entityType + "."
+                            + option.get().name());
+                        if (isBlank(relationname)) {
+                            return false;
+                        }
+
+                        //because we check the criteria is not valid we have to check the opposite
+                        if (configurationService.getBooleanProperty("orcid.relation." + entityType + "."
+                            + option.get().name() + ".exclusion", false)) {
+                            //check, if any relationship exists between profile and item (e.g. MINE)
+                            return relationShipMatchForOrcidSync(context, profile, item, relationname, true);
+                        } else {
+                            //check if none relationship exist between profile and item (e.g. MY_SELECT)
+                            return relationShipMatchForOrcidSync(context, profile, item, relationname, false);
+                        }
+
+                    default:
+                        return false;
+                }
+            } catch (SQLException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        return false;
+    }
+
+    protected boolean relationShipMatchForOrcidSync(Context context, Item profile, Item item, String relationname,
+                                                    boolean any) throws SQLException {
+        if (any) {
+            return relationshipService.findByItem(context, profile).stream().anyMatch(relationship ->
+                relationship.getLeftItem().getID().toString().equals(item.getID().toString()) &&
+                    relationship.getLeftwardValue().contentEquals(relationname));
+        } else {
+            return relationshipService.findByItem(context, profile).stream().noneMatch(relationship ->
+                relationship.getLeftItem().getID().toString().equals(item.getID().toString()) &&
+                    relationship.getLeftwardValue().contentEquals(relationname));
+        }
+    }
+
     @Override
     public Optional<OrcidSynchronizationMode> getSynchronizationMode(Item item) {
         return getMetadataValue(item, "dspace.orcid.sync-mode")