Curator tool

src/main/java/org/reactome/server/graph/domain/model/Complex.java

@@ -43,6 +43,9 @@ public class Complex extends PhysicalEntity implements CompositionAggregator {
 
     @Relationship(type = "relatedSpecies")
     private List<Species> relatedSpecies;
+
+    @Relationship(type = "componentCellType")
+    private List<PhysicalEntityCellType> componentCellType;
 
     @Override
     public Stream<? extends Collection<? extends Has<? extends DatabaseObject>>> defineCompositionRelations() {
@@ -56,6 +59,14 @@ public Complex(Long dbId) {
         super(dbId);
     }
 
+    public List<PhysicalEntityCellType> getComponentCellType() {
+        return componentCellType;
+    }
+
+    public void setComponentCellType(List<PhysicalEntityCellType> componentCellType) {
+        this.componentCellType = componentCellType;
+    }
+
     public Boolean getIsChimeric() {
         return isChimeric;
     }

src/main/java/org/reactome/server/graph/domain/model/DatabaseObject.java

@@ -1,23 +1,28 @@
 package org.reactome.server.graph.domain.model;
 
-import com.fasterxml.jackson.annotation.JsonIdentityInfo;
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.fasterxml.jackson.annotation.ObjectIdGenerators;
+import java.io.Serializable;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
 import org.reactome.server.graph.domain.annotations.ReactomeProperty;
 import org.reactome.server.graph.domain.annotations.ReactomeSchemaIgnore;
 import org.reactome.server.graph.domain.annotations.ReactomeTransient;
+import org.reactome.server.graph.domain.relationship.ModifiedList;
 import org.reactome.server.graph.domain.result.DatabaseObjectLike;
 import org.springframework.data.neo4j.core.schema.Id;
 import org.springframework.data.neo4j.core.schema.Node;
 import org.springframework.data.neo4j.core.schema.Relationship;
 import org.springframework.lang.NonNull;
 
-import java.io.Serializable;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Objects;
+import com.fasterxml.jackson.annotation.JsonIdentityInfo;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.ObjectIdGenerators;
 
 /**
  * DatabaseObject contains the minimum fields used to define an instance of an Reactome entry
@@ -61,13 +66,21 @@ public abstract class DatabaseObject implements Serializable, Comparable<Databas
 
     @Relationship(type = "modified", direction = Relationship.Direction.INCOMING)
     private InstanceEdit modified;
+
+    // This is a list of InstanceEdits that have modified this DatabaseObject.
+    // So that we can track all modifications, not just the most recent one.
+    @Relationship(type = "modifiedList", direction = Relationship.Direction.INCOMING)
+    private SortedSet<ModifiedList> modifiedList;
+
+    @Relationship(type = "stableIdentifier")
+    private StableIdentifier stableIdentifier;
 
     public DatabaseObject() {
     }
 
     public DatabaseObject(Long dbId) {
         this.dbId = dbId;
-    }
+    } 
 
 //    @ReactomeSchemaIgnore
 //    public Long getId() {
@@ -78,6 +91,40 @@ public DatabaseObject(Long dbId) {
 //        this.id = id;
 //    }
 
+    public StableIdentifier getStableIdentifier() {
+        return stableIdentifier;
+    }
+
+    public void setStableIdentifier(StableIdentifier stableIdentifier) {
+        this.stableIdentifier = stableIdentifier;
+    }
+
+    public List<InstanceEdit> getModifiedList() {
+        if (this.modifiedList == null || this.modifiedList.isEmpty()) {
+            return null;
+        }
+
+        List<InstanceEdit> rtn = new ArrayList<>();
+        for (ModifiedList modified : this.modifiedList) {
+            rtn.add(modified.getInstanceEdit());
+        }
+        return rtn;
+    }
+
+    public void setModifiedList(List<InstanceEdit> modifiedList) {
+        if (modifiedList == null || modifiedList.isEmpty()) {
+            return;
+        }   
+        this.modifiedList = new TreeSet<>();
+        int order = 0;
+        for (InstanceEdit instanceEdit : modifiedList) {
+            ModifiedList aux = new ModifiedList();
+            aux.setInstanceEdit(instanceEdit);
+            aux.setOrder(order++);
+            this.modifiedList.add(aux);
+        }
+    }
+
     public Long getDbId() {
         return dbId;
     }

src/main/java/org/reactome/server/graph/domain/model/Deletable.java

@@ -6,7 +6,13 @@
 
 import java.util.List;
 
+/**
+ * This interface is not used any more because it limits the scope of replacementInstances in Deleted, which is supposed to
+ * cover all different types of DatabaseObjects. It is kept for backward compatibility with the old code since the nodes have
+ * been already created in the database. The interface may not be removed in the future, but should never be used in new code.
+ */
 @Node
+@Deprecated
 public interface Deletable extends DatabaseObjectLike {
     List<Deleted> getDeleted();
 }

src/main/java/org/reactome/server/graph/domain/model/Deleted.java

@@ -21,11 +21,14 @@ public class Deleted extends MetaDatabaseObject{
     private DeletedControlledVocabulary reason;
 
     @Relationship(type="replacementInstances")
-    private List<Deletable> replacementInstances;
+    private List<DatabaseObject> replacementInstances;
 
     @Deprecated
     @ReactomeProperty(originName = "deletedInstanceDB_ID")
     private List<Integer> deletedInstanceDbId;
+
+    @ReactomeProperty(originName = "replacementInstanceDB_IDs")
+    private List<Integer> replacementInstanceDbIds;
 
     public Deleted() {
     }
@@ -34,6 +37,14 @@ public String getCuratorComment() {
         return curatorComment;
     }
 
+    public List<Integer> getReplacementInstanceDbIds() {
+        return replacementInstanceDbIds;
+    }
+
+    public void setReplacementInstanceDbIds(List<Integer> replacementInstanceDbIds) {
+        this.replacementInstanceDbIds = replacementInstanceDbIds;
+    }
+
     public void setCuratorComment(String curatorComment) {
         this.curatorComment = curatorComment;
     }
@@ -54,11 +65,11 @@ public void setReason(DeletedControlledVocabulary reason) {
         this.reason = reason;
     }
 
-    public List<Deletable> getReplacementInstances() {
+    public List<DatabaseObject> getReplacementInstances() {
         return replacementInstances;
     }
 
-    public void setReplacementInstances(List<Deletable> replacementInstances) {
+    public void setReplacementInstances(List<DatabaseObject> replacementInstances) {
         this.replacementInstances = replacementInstances;
     }
 

src/main/java/org/reactome/server/graph/domain/model/Event.java

@@ -4,13 +4,25 @@
 import org.reactome.server.graph.domain.annotations.*;
 import org.reactome.server.graph.domain.relationship.EventOf;
 import org.reactome.server.graph.domain.relationship.Has;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+
+import org.reactome.server.graph.domain.annotations.ReactomeProperty;
+import org.reactome.server.graph.domain.annotations.ReactomeSchemaIgnore;
+import org.reactome.server.graph.domain.annotations.ReactomeTransient;
 import org.reactome.server.graph.domain.relationship.HasCompartment;
+import org.reactome.server.graph.domain.relationship.StructureModified;
 import org.springframework.data.neo4j.core.schema.Node;
 import org.springframework.data.neo4j.core.schema.Relationship;
 
 import java.util.List;
 import java.util.Set;
 import java.util.SortedSet;
+import com.fasterxml.jackson.annotation.JsonIgnore;
 
 @SuppressWarnings({"unused"})
 
@@ -40,6 +52,8 @@ public abstract class Event extends DatabaseObject implements Trackable, Deletab
     private String releaseStatus;
     @ReactomeProperty(addedField = true)
     private String speciesName;
+    @ReactomeProperty(originName = "_doRelease")
+    private Boolean doRelease;
 
     @Relationship(type = "authored", direction = Relationship.Direction.INCOMING)
     private List<InstanceEdit> authored;
@@ -115,8 +129,13 @@ public abstract class Event extends DatabaseObject implements Trackable, Deletab
     @Relationship(type = "internalReviewed", direction = Relationship.Direction.INCOMING)
     private List<InstanceEdit> internalReviewed;
 
+    // For some reason, we have to define a relationship to keep the order
+    // for newly added InstanceEdit in this attribute. Not sure why.
+    // Use SortedSet to make sure the order is correct. Most likely
+    // the sorting is conducted when the list, which is generated by the framework(?), is
+    // converted into a SortedSet.
     @Relationship(type = "structureModified", direction = Relationship.Direction.INCOMING)
-    private List<InstanceEdit> structureModified;
+    private SortedSet<StructureModified> structureModified;
 
     @ReactomeTransient
     @Relationship(type = "replacementInstances", direction = Relationship.Direction.INCOMING)
@@ -404,11 +423,26 @@ public void setInternalReviewed(List<InstanceEdit> internalReviewed) {
     }
 
     public List<InstanceEdit> getStructureModified() {
-        return structureModified;
+        if (structureModified == null || structureModified.isEmpty())
+            return null;
+        return this.structureModified.stream().map(s -> s.getInstanceEdit()).collect(Collectors.toList());
     }
 
     public void setStructureModified(List<InstanceEdit> structureModified) {
-        this.structureModified = structureModified;
+        if (structureModified != null && structureModified.size() > 0) {
+            int order = 0;
+            this.structureModified = new TreeSet<>();
+            for (InstanceEdit ie : structureModified) {
+                StructureModified sm = new StructureModified();
+                sm.setId(ie.getDbId());
+                sm.setInstanceEdit(ie);
+                sm.setOrder(order);
+                order ++;
+                this.structureModified.add(sm);
+            }
+        }
+        else
+            this.structureModified = null;
     }
 
     @Override
@@ -436,4 +470,13 @@ public Integer getMaxDepth() {
     public void setMaxDepth(Integer maxDepth) {
         this.maxDepth = maxDepth;
     }
+
+
+    public Boolean getDoRelease() {
+        return doRelease;
+    }
+
+    public void setDoRelease(Boolean doRelease) {
+        this.doRelease = doRelease;
+    }
 }

src/main/java/org/reactome/server/graph/domain/model/ExternalOntology.java

@@ -32,6 +32,13 @@ public abstract class ExternalOntology extends DatabaseObject {
     public ExternalOntology() {}
 
     public String getDatabaseName() {
+        // Not all instances having databaseName setting. Therefore,
+        // the code also tries to get the database name from referenceDatabase.
+        // Not sure why databaseName is set in the first place. Most likely
+        // for performance reason.
+        if (databaseName == null && referenceDatabase != null) {
+            return referenceDatabase.getDisplayName();
+        }
         return databaseName;
     }
 

src/main/java/org/reactome/server/graph/domain/model/GO_BiologicalProcess.java

@@ -4,7 +4,7 @@
 
 @SuppressWarnings("unused")
 @Node
-public class GO_BiologicalProcess extends GO_Term{
+public class GO_BiologicalProcess extends GO_Term {
 
     public GO_BiologicalProcess() {}
 

src/main/java/org/reactome/server/graph/domain/model/GO_CellularComponent.java

@@ -15,9 +15,6 @@ public class GO_CellularComponent extends GO_Term {
     @Relationship(type = "hasPart")
     private List<GO_CellularComponent> hasPart;
 
-    @Relationship(type = "instanceOf")
-    private List<GO_CellularComponent> instanceOf;
-
     @Relationship(type = "surroundedBy")
     private List<GO_CellularComponent> surroundedBy;
 
@@ -43,14 +40,6 @@ public void setHasPart(List<GO_CellularComponent> hasPart) {
         this.hasPart = hasPart;
     }
 
-    public List<GO_CellularComponent> getInstanceOf() {
-        return instanceOf;
-    }
-
-    public void setInstanceOf(List<GO_CellularComponent> instanceOf) {
-        this.instanceOf = instanceOf;
-    }
-
     public List<GO_CellularComponent> getSurroundedBy() {
         return surroundedBy;
     }