public void randomlyMapDiseaseNodesToNormalNodes(
Map<Node, GKInstance> normalToDiseaseEntity,
Collection<GKInstance> mapped,
List<GKInstance> diseaseInputs,
List<Node> normalNodes) {
if (diseaseInputs != null && diseaseInputs.size() > 0) {
normalNodes.removeAll(normalToDiseaseEntity.keySet());
if (normalNodes.size() > 0) {
for (GKInstance input : diseaseInputs) {
// if (mapped.contains(input))
if (contains(input, mapped)) continue; // it has been mapped already
// Check if it has been used based on DB_ID
Node matched = null;
for (Node node : normalNodes) {
if (node.getReactomeId().equals(input.getDBID())) {
matched = node;
break;
}
}
if (matched == null)
// Just pick up the first node
matched = normalNodes.get(0);
normalToDiseaseEntity.put(matched, input);
normalNodes.remove(matched);
if (normalNodes.size() == 0) break;
}
}
}
}
/**
* Some of disease reactions may not be drawn in the pathway diagram (e.g. LoF or GoF reactions).
* These reactions should be overlaid onto their normalReaction counterparts, which are encoded by
* their normalReaction attributes.
*
* @param diseaseIds
*/
private void overlayDiseaseReactions(Set<Long> diseaseIds) {
// Get the list of all drawing objects for checking
Map<Long, Renderable> idToObject = new HashMap<Long, Renderable>();
List<Renderable> components = displayedObject.getComponents();
if (components == null || components.size() == 0) return;
for (Renderable r : components) {
if (r.getReactomeId() == null) continue;
idToObject.put(r.getReactomeId(), r);
}
try {
normalToDiseaseNode = new HashMap<Node, Node>();
for (Long diseaseId : diseaseIds) {
if (idToObject.containsKey(diseaseId)) continue;
// Have to copy the normal reactions to draw
GKInstance inst = adaptor.fetchInstance(diseaseId);
if (inst.getSchemClass().isa(ReactomeJavaConstants.ReactionlikeEvent)) {
List<GKInstance> normalReactions =
inst.getAttributeValuesList(ReactomeJavaConstants.normalReaction);
if (normalReactions != null && normalReactions.size() > 0) {
for (GKInstance normalRxt : normalReactions) {
Renderable r = idToObject.get(normalRxt.getDBID());
if (r instanceof HyperEdge) overlayDiseaseReaction((HyperEdge) r, inst);
}
}
}
}
return;
} catch (Exception e) {
e.printStackTrace();
}
}
private void clearDeleteRecord() {
if (deleteList != null) {
java.util.List list = deleteList.getSelection();
if (list.size() > 0) {
try {
java.util.List dbIDs = new ArrayList(list.size());
for (Iterator it = list.iterator(); it.hasNext(); ) {
GKInstance instance = (GKInstance) it.next();
dbIDs.add(instance.getDBID());
}
fileAdaptor.clearDeleteRecord(dbIDs);
} catch (IOException e) {
System.err.println("SynchronizationDialog.clearDeleteRecord(): " + e);
e.printStackTrace();
}
deleteList.deleteInstances(list);
// Check if deleteList needs to be removed
if (deleteList.getDisplayedInstances().size() == 0) {
centerPane.remove(deleteList);
centerPane.validate();
centerPane.repaint();
}
}
}
}
@Test
public void checkReferenceMoleculeAndClassUsage() throws Exception {
MySQLAdaptor dba =
new MySQLAdaptor("reactomedev.oicr.on.ca", "gk_central", "authortool", "**REMOVED**");
// Collection<GKInstance> c =
// dba.fetchInstancesByClass(ReactomeJavaConstants.ReferenceGroupCount);
// System.out.println("Total ReferenceMolecule: " + c.size());
Collection<GKInstance> c1 =
dba.fetchInstancesByClass(ReactomeJavaConstants.ReferenceMoleculeClass);
System.out.println("Total ReferenceMoleculeClass: " + c1.size());
Set<GKInstance> all = new HashSet<GKInstance>();
// all.addAll(c);
all.addAll(c1);
System.out.println("ReferenceMolecule\tReferrers");
for (GKInstance inst : all) {
Collection<?> refAtts = inst.getSchemClass().getReferers();
Set<GKInstance> allReferrers = new HashSet<GKInstance>();
for (Iterator<?> it1 = refAtts.iterator(); it1.hasNext(); ) {
GKSchemaAttribute att = (GKSchemaAttribute) it1.next();
Collection<GKInstance> referrers = inst.getReferers(att);
if (referrers != null) allReferrers.addAll(referrers);
}
if (allReferrers.size() > 0) {
System.out.println(inst + "\t" + join(allReferrers));
}
}
}
public Component getListCellRendererComponent(
JList list, Object value, int index, boolean isSelected, boolean hasFocus) {
Component comp =
super.getListCellRendererComponent(list, value, index, isSelected, hasFocus());
if (!(value instanceof GKInstance)) return comp;
String text = null;
GKInstance instance = (GKInstance) value;
text = instance.getDisplayName();
if (text == null || (text != null && text.length() == 0)) {
text = instance.getExtendedDisplayName();
}
String type = (String) typeMap.get(instance);
if (type == DELETE_IN_DB_KEY) setIcon(deleteInDBIcon);
else if (type == DELETE_KEY) setIcon(deleteIcon);
else if (type == NEW_KEY) setIcon(newInstanceIcon);
else if (type == NEW_CHANGE_IN_DB_KEY) setIcon(dbChangeIcon);
else if (type == NEW_CHANGE_IN_LOCAL_KEY) setIcon(newChangeIcon);
else if (type == CONFLICT_CHANGE_KEY || type == LOCAL_HAS_MORE_IE_KEY) setIcon(conflictIcon);
else setIcon(icon);
if (text == null) {
text = "";
setIcon(null);
}
setText(text);
if (text.length() > 0) setToolTipText(text);
else setToolTipText(null);
return comp;
}
private boolean isLOFEntity(GKInstance ef) throws Exception {
GKInstance pe = (GKInstance) ef.getAttributeValue(ReactomeJavaConstants.physicalEntity);
if (pe == null) return false;
GKInstance functionalStatus =
(GKInstance) ef.getAttributeValue(ReactomeJavaConstants.functionalStatus);
if (functionalStatus != null) {
String fsName = functionalStatus.getDisplayName();
if (fsName.contains("loss_of_function") || fsName.contains("decreased_")) return true;
}
return false;
}
@Override
public void postMap(
OWLIndividual bpInstance,
BioPAXFactory bpFactor,
XMLFileAdaptor reactomeAdaptor,
Map<OWLIndividual, GKInstance> bpToRInstanceMap)
throws Exception {
// Sort hasComponent or hasEvent attributes based on preceding/following.
GKInstance pathway = (GKInstance) bpToRInstanceMap.get(bpInstance);
SchemaAttribute attribute = null;
if (pathway.getSchemClass().isValidAttribute(ReactomeJavaConstants.hasComponent))
attribute = pathway.getSchemClass().getAttribute(ReactomeJavaConstants.hasComponent);
else if (pathway.getSchemClass().isValidAttribute(ReactomeJavaConstants.hasEvent))
attribute = pathway.getSchemClass().getAttribute(ReactomeJavaConstants.hasEvent);
if (attribute == null) return;
List originalValues = pathway.getAttributeValuesList(attribute);
if (originalValues == null || originalValues.size() < 2) return; // No need to order
List copy = new ArrayList(originalValues);
for (Iterator it = copy.iterator(); it.hasNext(); ) {
GKInstance inst = (GKInstance) it.next();
int index = originalValues.indexOf(inst);
List preceded = inst.getAttributeValuesList(ReactomeJavaConstants.precedingEvent);
if (preceded == null || preceded.size() == 0) continue;
for (Iterator it1 = preceded.iterator(); it1.hasNext(); ) {
GKInstance tmp = (GKInstance) it1.next();
int tmpIndex = originalValues.indexOf(tmp);
if (tmpIndex > index) {
originalValues.remove(tmpIndex);
originalValues.add(index, tmp);
index++; // Move one step
}
}
}
}
private void convertReactomeToGPML(GKInstance pathway, String outputFileName) throws Exception {
Long dbID = pathway.getDBID();
System.out.println("converting pathway #" + dbID + " " + pathway.getDisplayName() + "...");
Document doc = r2gConverter.convertPathway(pathway);
XMLOutputter outputter = new XMLOutputter(Format.getPrettyFormat());
outputter.output(doc, new FileOutputStream(outputFileName));
/*
// Test loading using JDOM and validation
SAXBuilder builder = new SAXBuilder(true);
builder.setFeature("http://apache.org/xml/features/validation/schema", true);
builder.setProperty("http://apache.org/xml/properties/schema/external-schemaLocation",
"http://genmapp.org/GPML/2008a http://svn.bigcat.unimaas.nl/pathvisio/trunk/GPML2008a.xsd");
doc = builder.build(new File(outputFileName));
*/
}
@Override
protected void reinsert(DefaultMutableTreeNode treeNode, DefaultTreeModel model) {
DefaultMutableTreeNode parent = (DefaultMutableTreeNode) treeNode.getParent();
model.removeNodeFromParent(treeNode);
// Check if the old parent can still be used in case type has been changed
GKSchemaClass parentCls = (GKSchemaClass) parent.getUserObject();
GKInstance editingInstance = (GKInstance) treeNode.getUserObject();
if (editingInstance.getSchemClass().isa(parentCls))
insertInstanceNodeAlphabetically(parent, treeNode);
else {
// Need to insert into another node
DefaultMutableTreeNode newParent = getClassNode(editingInstance.getSchemClass());
insertInstanceNodeAlphabetically(newParent, treeNode);
// Check if the old parent node should be removed
if (parent.getChildCount() == 0) model.removeNodeFromParent(parent);
}
}
/**
* Map mutated nodes in a disease reaction to displayed nodes in a normal reaction. The mapping is
* based on sharing of referenceEntity. This may not be reliable!
*
* @param diseaseReaction
* @param nodes
* @throws InvalidAttributeException
* @throws Exception @TODO: add a new attribute normalEntity in the PhysicalEntity class.
*/
private Map<Node, GKInstance> mapMutatedToNormalNodes(
GKInstance diseaseReaction,
HyperEdge normalReaction,
List<Node> nodes,
Set<GKInstance> lofInstances)
throws InvalidAttributeException, Exception {
List<GKInstance> efs =
diseaseReaction.getAttributeValuesList(ReactomeJavaConstants.entityFunctionalStatus);
// Map mutated entities to normal entities via ReferenceGeneProduct
Map<Node, GKInstance> normalToDiseaseEntity = new HashMap<Node, GKInstance>();
if (efs == null) return normalToDiseaseEntity;
for (GKInstance ef : efs) {
GKInstance pe = (GKInstance) ef.getAttributeValue(ReactomeJavaConstants.physicalEntity);
if (pe != null) {
Set<GKInstance> refEntities = getReferenceEntity(pe);
// want to find the matched node
for (Node node : nodes) {
if (node.getReactomeId() == null) continue;
GKInstance nodeInst = adaptor.fetchInstance(node.getReactomeId());
Set<GKInstance> nodeRefEntities = getReferenceEntity(nodeInst);
nodeRefEntities.retainAll(refEntities);
if (nodeRefEntities.size() > 0) {
normalToDiseaseEntity.put(node, pe);
if (isLOFEntity(ef)) {
lofInstances.add(pe);
}
break;
}
}
}
}
// TODO: May have to consider stoichiometries too!!!
// In gain of functions, some inputs or outputs may not be used by normal reactions.
// This method will do its best to map these reaction participants
Collection<GKInstance> mapped = normalToDiseaseEntity.values();
// First check inputs
List<GKInstance> diseaseInputs =
diseaseReaction.getAttributeValuesList(ReactomeJavaConstants.input);
List<Node> normalNodes = normalReaction.getInputNodes();
randomlyMapDiseaseNodesToNormalNodes(normalToDiseaseEntity, mapped, diseaseInputs, normalNodes);
// Check outputs
List<GKInstance> diseaseOutputs =
diseaseReaction.getAttributeValuesList(ReactomeJavaConstants.output);
normalNodes = normalReaction.getOutputNodes();
randomlyMapDiseaseNodesToNormalNodes(
normalToDiseaseEntity, mapped, diseaseOutputs, normalNodes);
// Check helpers
GKInstance ca =
(GKInstance) diseaseReaction.getAttributeValue(ReactomeJavaConstants.catalystActivity);
if (ca != null) {
List<GKInstance> catalysts = ca.getAttributeValuesList(ReactomeJavaConstants.physicalEntity);
normalNodes = normalReaction.getHelperNodes();
randomlyMapDiseaseNodesToNormalNodes(normalToDiseaseEntity, mapped, catalysts, normalNodes);
}
return normalToDiseaseEntity;
}
@Override
public void addInstance(GKInstance instance) {
SchemaClass cls = instance.getSchemClass();
if (!cls.isa(ReactomeJavaConstants.PhysicalEntity) || cls.isa(ReactomeJavaConstants.Complex))
return; // Only display non-complex PE in this class.
DefaultMutableTreeNode clsNode = getClassNode(cls);
DefaultMutableTreeNode instanceNode = new DefaultMutableTreeNode(instance);
insertInstanceNodeAlphabetically(clsNode, instanceNode);
}
private Node replaceNormalNode(
Node normalNode, GKInstance diseaseEntity, Boolean needDashedBorder) {
Node diseaseNode = normalToDiseaseNode.get(normalNode);
if (diseaseNode != null) return diseaseNode;
try {
// If a node exists already, it should use
for (Renderable r : diseaseComps) {
if (diseaseEntity.getDBID().equals(r.getReactomeId()) && r instanceof Node) {
// This is rather arbitrary: if two nodes are very close,
// use the existing one.
int dx = Math.abs(r.getPosition().x - normalNode.getPosition().x);
int dy = Math.abs(r.getPosition().y - normalNode.getPosition().y);
if (dx < 10 && dy < 10) {
// We don't need to create a new Node if it exists already
normalToDiseaseNode.put(normalNode, (Node) r);
overlaidObjects.add(r); // Add it to overlaid object to cover edges
return (Node) r;
}
}
}
diseaseNode = normalNode.getClass().newInstance();
RenderUtility.copyRenderInfo(normalNode, diseaseNode);
// The following should NOT be called since NodeAttachment is
// related to disease entity only.
// TODO: Need to support this. Currently it is not supported!!! See example
// in PI3/AKT cancer pathway.
// diseaseNode.setNodeAttachmentsLocally(node.getNodeAttachments());
diseaseNode.setDisplayName(diseaseEntity.getDisplayName());
diseaseNode.setReactomeId(diseaseEntity.getDBID());
diseaseNode.invalidateBounds();
diseaseNode.setRenderer(normalNode.getRenderer());
diseaseNode.setLineColor(DefaultRenderConstants.DEFAULT_DISEASE_BACKGROUND);
diseaseNode.setNeedDashedBorder(needDashedBorder);
RenderUtility.hideCompartmentInNodeName(diseaseNode);
overlaidObjects.add(diseaseNode);
displayedObject.addComponent(diseaseNode);
normalToDiseaseNode.put(normalNode, diseaseNode);
return diseaseNode;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
private Set<GKInstance> getReferenceEntity(GKInstance pe) throws Exception {
Set<GKInstance> rtn = new HashSet<GKInstance>();
if (pe.getSchemClass().isValidAttribute(ReactomeJavaConstants.referenceEntity)) {
GKInstance ref = (GKInstance) pe.getAttributeValue(ReactomeJavaConstants.referenceEntity);
if (ref != null) rtn.add(ref);
return rtn;
}
Set<GKInstance> contained =
InstanceUtilities.getContainedInstances(
pe,
ReactomeJavaConstants.hasMember,
ReactomeJavaConstants.hasCandidate,
ReactomeJavaConstants.hasComponent);
// Check member or complex subunits
for (GKInstance tmp : contained) {
if (tmp.getSchemClass().isValidAttribute(ReactomeJavaConstants.referenceEntity)) {
GKInstance ref = (GKInstance) tmp.getAttributeValue(ReactomeJavaConstants.referenceEntity);
if (ref != null) rtn.add(ref);
}
}
return rtn;
}
public boolean shouldEscape(GKInstance inst) {
if (!needEscapePermissioin) return false;
if (needEscape && escapedDbIds.contains(inst.getDBID())) {
if (cutoffDate != null) {
try {
// Check if the latest IEs is later than the cutoff date
GKInstance latestIE = InstanceUtilities.getLatestIEFromInstance(inst);
// Just in case
if (latestIE == null) return true;
String ieDateValue = (String) latestIE.getAttributeValue(ReactomeJavaConstants.dateTime);
// Have to make sure default date instance is used!
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.S");
Date ieDate = df.parse(ieDateValue);
return !ieDate.after(cutoffDate);
} catch (Exception e) {
// Don't want to show a GUI here. Just generate error message silently.
System.err.println("QAEscapeHelper.shouldEscape(): " + e);
e.printStackTrace();
return false;
}
} else return true;
}
return false;
}
private void getPathwayComponents(
OWLIndividual bpInstance,
BioPAXFactory bpFactory,
GKInstance rPathway,
Map<OWLIndividual, GKInstance> bpToRInstanceMap)
throws Exception {
OWLProperty prop = bpFactory.getOWLProperty(BioPAXJavaConstants.PATHWAY_COMPONENTS);
Collection bpComponents = bpInstance.getPropertyValues(prop);
if (bpComponents == null || bpComponents.size() == 0) return;
OWLIndividual bpComp;
RDFSClass bpCompType;
GKInstance rComp;
// Used to check value
// Try to make it work for the new schema (6/13/07 - wgm)
SchemaAttribute hasComponentAtt = null;
if (rPathway.getSchemClass().isValidAttribute(ReactomeJavaConstants.hasComponent))
hasComponentAtt = rPathway.getSchemClass().getAttribute(ReactomeJavaConstants.hasComponent);
else if (rPathway.getSchemClass().isValidAttribute(ReactomeJavaConstants.hasEvent))
hasComponentAtt = rPathway.getSchemClass().getAttribute(ReactomeJavaConstants.hasEvent);
if (hasComponentAtt == null) return;
// Do a sort based on NEXT_STEP
for (Iterator it = bpComponents.iterator(); it.hasNext(); ) {
Object obj = it.next();
if (!(obj instanceof OWLIndividual)) {
System.out.println(obj + " is not an OWLIndividual object!");
throw new IllegalStateException(
"Object in the pathway component list is not an OWLIndividual object: " + obj);
}
bpComp = (OWLIndividual) obj;
bpCompType = bpComp.getRDFType();
if (bpCompType == bpFactory.getpathwayStepClass()) {
// Grep the wrapped interaction or pathway instances
prop = bpFactory.getOWLProperty(BioPAXJavaConstants.STEP_INTERACTIONS);
Collection stepInteractions = bpComp.getPropertyValues(prop);
if (stepInteractions == null || stepInteractions.size() == 0) continue;
for (Iterator it1 = stepInteractions.iterator(); it1.hasNext(); ) {
OWLIndividual stepInteraction = (OWLIndividual) it1.next();
if (stepInteraction.getRDFType() != bpFactory.getcontrolClass()) {
rComp = bpToRInstanceMap.get(stepInteraction);
// Some control Individuals are listed under PATHWAY_COMPONENT. However,
// they should not be a value in hasComponent
if (rComp != null && hasComponentAtt.isValidValue(rComp))
rPathway.addAttributeValue(hasComponentAtt, rComp);
}
}
} else if (bpCompType != bpFactory.getcontrolClass()
&& !bpCompType.isSubclassOf(bpFactory.getcontrolClass())) {
// Another two types should be: Interaction and Pathway. But should exclude
// control class. Control class is attached to Reaction in Reactome
rComp = bpToRInstanceMap.get(bpComp);
if (rComp != null) rPathway.addAttributeValue(hasComponentAtt, rComp);
}
}
}
/**
* This method is used to dump all human pathway diagrams into a specified directory.
*
* @param dir
* @throws Exception
*/
public void dumpHumanPathwayDiagrams(File dir) throws Exception {
Collection<?> diagrams = adaptor.fetchInstancesByClass(ReactomeJavaConstants.PathwayDiagram);
SchemaClass cls = adaptor.fetchSchema().getClassByName(ReactomeJavaConstants.PathwayDiagram);
SchemaAttribute att = cls.getAttribute(ReactomeJavaConstants.representedPathway);
adaptor.loadInstanceAttributeValues(diagrams, att);
// Group all human pathways
for (Iterator<?> it = diagrams.iterator(); it.hasNext(); ) {
GKInstance diagram = (GKInstance) it.next();
GKInstance pathway =
(GKInstance) diagram.getAttributeValue(ReactomeJavaConstants.representedPathway);
GKInstance species = (GKInstance) pathway.getAttributeValue(ReactomeJavaConstants.species);
if (species == null) continue;
if (species.getDBID().equals(48887L)) {
String fileName = getFileName(pathway);
File file = new File(dir, fileName);
convertReactomeToGPML(pathway, file.getAbsolutePath());
}
}
}
private void checkLossOfFunctionNodes() {
try {
lofNodes = new ArrayList<Node>();
List<Renderable> components = displayedObject.getComponents();
if (components == null || components.size() == 0) return;
for (Renderable r : components) {
if (r instanceof Node || r.getReactomeId() == null) continue;
if (!diseaseIds.contains(r.getReactomeId())) continue;
GKInstance inst = adaptor.fetchInstance(r.getReactomeId());
if (!inst.getSchemClass().isa(ReactomeJavaConstants.ReactionlikeEvent)
|| !inst.getSchemClass().isValidAttribute(ReactomeJavaConstants.entityFunctionalStatus))
continue;
List<GKInstance> efs =
inst.getAttributeValuesList(ReactomeJavaConstants.entityFunctionalStatus);
Set<GKInstance> lofPEs = new HashSet<GKInstance>();
for (GKInstance ef : efs) {
GKInstance pe = (GKInstance) ef.getAttributeValue(ReactomeJavaConstants.physicalEntity);
if (isLOFEntity(ef)) lofPEs.add(pe);
}
List<Node> nodes = ((HyperEdge) r).getConnectedNodes();
for (Node node : nodes) {
if (node.getReactomeId() == null) continue;
GKInstance nodeInst = adaptor.fetchInstance(node.getReactomeId());
Set<GKInstance> nodeRefEntities = getReferenceEntity(nodeInst);
for (GKInstance lofPE : lofPEs) {
Set<GKInstance> lofRefEntities = getReferenceEntity(lofPE);
lofRefEntities.retainAll(nodeRefEntities);
if (lofRefEntities.size() > 0) {
// A LOF node
lofNodes.add(node);
break;
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
private void showComparison() {
// Find the instance that can be used for comparision. This instance
// should be chosen from changedList or localHasUnexpInstance
GKInstance instance = null;
if (changedList != null) { // Check changedList first
List selection = changedList.getSelection();
if (selection.size() > 0) instance = (GKInstance) selection.get(0);
}
if (instance == null && localHasMoreIEList != null) {
List selection = localHasMoreIEList.getSelection();
if (selection.size() > 0) instance = (GKInstance) selection.get(0);
}
if (instance == null) return;
final InstanceComparisonPane comparisonPane = new InstanceComparisonPane();
// Fine tune comparison pane for making comparisons with
// database
comparisonPane.setSaveDialogHideUnusedButtons(true);
comparisonPane.setSaveDialogSaveAsNewBtnFirst(false);
comparisonPane.setSaveDialogSaveAsNewBtnTitle(
"Create new local instance and put merge into that");
comparisonPane.setSaveDialogReplaceFirstBtnTitle(
"Overwrite existing instance with merge (recommended)");
comparisonPane.setCloseAfterSaving(true);
try {
String clsName = instance.getSchemClass().getName();
Long instanceId = instance.getDBID();
final GKInstance localCopy = fileAdaptor.fetchInstance(clsName, instanceId);
dbAdaptor.setUseCache(false);
// final GKInstance dbCopy = dbAdaptor.fetchInstance(clsName, instanceId);
// The class type might be changed locally or remotely. So not clsName should be used
// to fetch database instance. Otherwise, null exception will be thrown. The same thing
// is done also in creating synchronization result.
final GKInstance dbCopy = dbAdaptor.fetchInstance(instanceId);
dbAdaptor.setUseCache(true);
comparisonPane.setInstances(localCopy, dbCopy);
String title =
"Comparing Instances \""
+ instance.getDisplayName()
+ "\" in the local and DB repositories";
JDialog parentDialog = (JDialog) SwingUtilities.getAncestorOfClass(JDialog.class, centerPane);
final JDialog dialog = new JDialog(parentDialog, title);
// Try to update the list automatically
dialog.addWindowListener(
new WindowAdapter() {
public void windowClosed(WindowEvent e) {
handleMergeResult(localCopy, dbCopy, comparisonPane);
// To prevent double calling. It is called again when parentDialog is closed.
dialog.removeWindowListener(this);
}
});
dialog.getContentPane().add(comparisonPane, BorderLayout.CENTER);
dialog.setModal(true);
dialog.setSize(800, 600);
GKApplicationUtilities.center(dialog);
dialog.setVisible(true);
// Update synchronization dialog panels depending on user
// choice.
if (comparisonPane.getSaveMergeOption() == InstanceComparisonPane.SAVE_AS_NEW) {
GKInstance merged = comparisonPane.getMerged();
if (newList == null) {
List list = new ArrayList();
list.add(merged);
newList = initInstanceListPane(list, "Instances created locally: " + list.size());
} else newList.addInstance(merged);
} else if (comparisonPane.getSaveMergeOption() == InstanceComparisonPane.OVERWRITE_FIRST) {
dbAdaptor.setUseCache(false);
GKInstance remoteCopy = dbAdaptor.fetchInstance(instance.getDBID());
dbAdaptor.setUseCache(true);
if (remoteCopy != null) {
InstanceComparer comparer = new InstanceComparer();
int reply = comparer.compare(instance, remoteCopy);
if (reply == InstanceComparer.LOCAL_HAS_MORE_IE) {
if (localHasMoreIEList == null) {
List list = new ArrayList();
list.add(instance);
localHasMoreIEList =
initInstanceListPane(
list, "Local instances having unexpected InstanceEdits: " + list.size());
} else localHasMoreIEList.addInstance(instance);
} else if (reply == InstanceComparer.IS_IDENTICAL) {
// Merge has made local and database copies
// identical - don't need to check in anymore
changedList.deleteInstance(instance);
} else if (reply != InstanceComparer.NEW_CHANGE_IN_LOCAL) {
// Merge has produced a conflict
typeMap.put(mapCompareResultToString(reply), instance);
} else
// The user should now be allowed to commit this
// instance, because it will now have changed.
commitToDBAction.setEnabled(true);
JOptionPane.showMessageDialog(
parentDialog,
"Merge successful, you will need to check the merged instance into the database.\n\n",
"Merge OK",
JOptionPane.INFORMATION_MESSAGE);
}
}
} catch (Exception e1) {
System.err.println("Synchronization.createDisplayMapPane(): " + e1);
e1.printStackTrace();
JOptionPane.showMessageDialog(
this,
"Error in comparing: " + instance.toString(),
"Error in Comparing",
JOptionPane.ERROR_MESSAGE);
}
}
private void updateFromDB() {
InstanceListPane touchedList = null;
// Find out which instances have been selected in all relevant lists
// Update the attribute values for changed list.
try {
if (changedList != null) {
java.util.List list = new ArrayList(changedList.getSelection()); // To support it.remove()
// Use a new ArrayList.
if (list != null && list.size() > 0) {
for (Iterator it = list.iterator(); it.hasNext(); ) {
GKInstance instance = (GKInstance) it.next();
// Fetch GKInstance based on its DB_ID since SchemaClass might be changed.
GKInstance localCopy = fileAdaptor.fetchInstance(instance.getDBID());
dbAdaptor.setUseCache(false);
GKInstance dbCopy = dbAdaptor.fetchInstance(instance.getDBID());
dbAdaptor.setUseCache(true);
if (SynchronizationManager.getManager().updateFromDB(localCopy, dbCopy, this)) {
AttributeEditManager.getManager().attributeEdit(localCopy);
fileAdaptor.removeDirtyFlag(localCopy);
} else it.remove(); // Remove from the list
}
// Remove all selected instances
changedList.deleteInstances(list);
touchedList = changedList;
}
}
if (localHasMoreIEList != null && localHasMoreIEList.getSelection().size() > 0) {
List list = new ArrayList(localHasMoreIEList.getSelection());
for (Iterator it = list.iterator(); it.hasNext(); ) {
GKInstance localCopy = (GKInstance) it.next();
dbAdaptor.setUseCache(false);
GKInstance dbCopy = dbAdaptor.fetchInstance(localCopy.getDBID());
dbAdaptor.setUseCache(true);
if (SynchronizationManager.getManager().updateFromDB(localCopy, dbCopy, this)) {
AttributeEditManager.getManager().attributeEdit(localCopy);
fileAdaptor.removeDirtyFlag(localCopy);
} else it.remove(); // Remove from the list, if it it cancelled by the user.
}
localHasMoreIEList.deleteInstances(list);
touchedList = localHasMoreIEList;
}
// Delete the local copy for deleteInDBList.
if (deleteInDBList != null) {
java.util.List list = deleteInDBList.getSelection();
if (list != null && list.size() > 0) {
for (Iterator it = list.iterator(); it.hasNext(); ) {
GKInstance instance = (GKInstance) it.next();
fileAdaptor.deleteInstance(instance);
}
}
deleteInDBList.deleteInstances(list);
touchedList = deleteInDBList;
}
// Get another copy for the local repository
if (deleteList != null) {
java.util.List<?> list = deleteList.getSelection();
if (list != null && list.size() > 0) {
Map<SchemaClass, Set<GKInstance>> checkOutMap =
new HashMap<SchemaClass, Set<GKInstance>>(); // All checked out Instances
for (Iterator<?> it = list.iterator(); it.hasNext(); ) {
GKInstance instance = (GKInstance) it.next();
Map<SchemaClass, List<GKInstance>> schemaMap =
InstanceUtilities.listDownloadableInstances(instance);
// Have to merge schemaMap to checkOutMap
for (SchemaClass key : schemaMap.keySet()) {
List<GKInstance> list1 = schemaMap.get(key);
if (list1 != null && list1.size() > 0) {
Set<GKInstance> list2 = checkOutMap.get(key);
if (list2 == null) {
list2 = new HashSet<GKInstance>();
checkOutMap.put(key, list2);
}
// Remove first to avoid any duplication
list2.addAll(list1);
}
}
}
fileAdaptor.store(checkOutMap);
InstanceUtilities.clearShellFlags(checkOutMap);
// There are maybe more than selected instances after checking out
List<GKInstance> checkedOut = new ArrayList<GKInstance>();
for (Set<GKInstance> set : checkOutMap.values()) {
checkedOut.addAll(set);
}
deleteList.deleteInstances(checkedOut);
// deleteList.deleteInstances(list);
// Need to clear out these deletion records
List<Long> dbIds = new ArrayList<Long>();
for (GKInstance inst : checkedOut) dbIds.add(inst.getDBID());
fileAdaptor.clearDeleteRecord(dbIds);
touchedList = deleteList;
}
}
} catch (Exception e) {
System.err.println("SynchronizationDialog.updateFromDB(): " + e);
e.printStackTrace();
}
updateInstanceList(touchedList);
}
/** Split objects into normal and disease components */
private void splitObjects() {
normalIds = new HashSet<Long>();
diseaseIds = new HashSet<Long>();
RenderablePathway diagram = (RenderablePathway) getRenderable();
if (pathway == null || diagram.getReactomeDiagramId() == null) return;
try {
GKInstance pdInst = adaptor.fetchInstance(diagram.getReactomeDiagramId());
// Get the disease pathway instance
List<GKInstance> pathways =
pdInst.getAttributeValuesList(ReactomeJavaConstants.representedPathway);
GKInstance diseasePathway = null;
GKInstance normalPathway = null;
GKInstance disease = (GKInstance) pathway.getAttributeValue(ReactomeJavaConstants.disease);
if (disease == null && contains(pathway, pathways)) {
normalPathway = pathway;
} else {
diseasePathway = pathway;
// There should be a normal pathway contained by a disease pathway
List<?> subPathways = diseasePathway.getAttributeValuesList(ReactomeJavaConstants.hasEvent);
for (Object obj : subPathways) {
GKInstance subPathway = (GKInstance) obj;
disease = (GKInstance) subPathway.getAttributeValue(ReactomeJavaConstants.disease);
if (disease == null && contains(subPathway, pathways)) {
normalPathway = subPathway;
break;
}
}
}
if (normalPathway != null) {
// Get all disease related objects
Set<GKInstance> normalEvents = InstanceUtilities.grepPathwayEventComponents(normalPathway);
for (GKInstance inst : normalEvents) normalIds.add(inst.getDBID());
Set<GKInstance> normalEntities = InstanceUtilities.grepPathwayParticipants(normalPathway);
for (GKInstance inst : normalEntities) normalIds.add(inst.getDBID());
if (diseasePathway != null) {
Set<GKInstance> allEvents = InstanceUtilities.grepPathwayEventComponents(diseasePathway);
allEvents.removeAll(normalEvents);
for (GKInstance inst : allEvents) {
diseaseIds.add(inst.getDBID());
// Want to make sure disease pathways are connected to objects
if (inst.getSchemClass().isa(ReactomeJavaConstants.ReactionlikeEvent)) {
Set<GKInstance> rxtEntities = InstanceUtilities.getReactionParticipants(inst);
for (GKInstance rxtEntity : rxtEntities) {
diseaseIds.add(rxtEntity.getDBID());
}
}
}
// Set<GKInstance> allEntities =
// InstanceUtilities.grepPathwayParticipants(diseasePathway);
// allEntities.removeAll(normalEntities);
// for (GKInstance inst : allEntities)
// diseaseIds.add(inst.getDBID());
}
}
splitComponents();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* A simple helper method to get a file name for gpml output.
*
* @param pathway
* @return
*/
private String getFileName(GKInstance pathway) {
return pathway.getDisplayName().replaceAll("[^0-9A-Za-z()_-]+", " ") + ".gpml";
}
/**
* In case where MySQLAdaptor cache is turned off, GKInstances having the same DB_IDs from the
* database are different during different queries. Using this helper method to check if a
* GKInstance is contained in a Collection<GKInstance> created in different time point.
*
* @param inst
* @param c
* @return
*/
private boolean contains(GKInstance inst, Collection<GKInstance> c) {
for (GKInstance inst1 : c) {
if (inst1.getDBID().equals(inst.getDBID())) return true;
}
return false;
}
/**
* Overlay a single disease reaction onto a normal reaction.
*
* @param normalReaction
* @param diseaseReaction
* @param overlaidObjects
*/
private void overlayDiseaseReaction(HyperEdge normalReaction, GKInstance diseaseReaction)
throws Exception {
// Make a copy of the HyperEdge for future process that is related to Vertex and JSON generation
HyperEdge reactionCopy = normalReaction.shallowCopy();
reactionCopy.setReactomeId(diseaseReaction.getDBID());
reactionCopy.setDisplayName(diseaseReaction.getDisplayName());
reactionCopy.setLineColor(DefaultRenderConstants.DEFAULT_DISEASE_BACKGROUND);
displayedObject.addComponent(reactionCopy);
overlaidObjects.add(reactionCopy);
// Want to handle inputs, outputs and catalysts since regulators can
// be ignored
List<Node> nodes = new ArrayList<Node>();
nodes.addAll(normalReaction.getInputNodes());
nodes.addAll(normalReaction.getOutputNodes());
nodes.addAll(normalReaction.getHelperNodes());
// List objects not listed in the disease reaction as crossed objects
Set<GKInstance> participants = InstanceUtilities.getReactionParticipants(diseaseReaction);
Set<Long> diseaseIds = new HashSet<Long>();
for (GKInstance participant : participants) {
diseaseIds.add(participant.getDBID());
if (participant.getSchemClass().isValidAttribute(ReactomeJavaConstants.hasMember)) {
List<GKInstance> list = participant.getAttributeValuesList(ReactomeJavaConstants.hasMember);
if (list != null && list.size() > 0) {
for (GKInstance inst : list) diseaseIds.add(inst.getDBID());
}
}
if (participant.getSchemClass().isValidAttribute(ReactomeJavaConstants.hasCandidate)) {
List<GKInstance> list =
participant.getAttributeValuesList(ReactomeJavaConstants.hasCandidate);
if (list != null && list.size() > 0) {
for (GKInstance inst : list) diseaseIds.add(inst.getDBID());
}
}
}
Set<GKInstance> lofInstances = new HashSet<GKInstance>();
Map<Node, GKInstance> normalToDiseaseEntity =
mapMutatedToNormalNodes(diseaseReaction, normalReaction, nodes, lofInstances);
for (Node node : nodes) {
if (!diseaseIds.contains(node.getReactomeId())) {
// Check if it should be mapped to a normal entity
GKInstance diseaseEntity = normalToDiseaseEntity.get(node);
if (diseaseEntity == null) crossedObjects.add(node); // Just crossed out
else {
Node diseaseNode =
replaceNormalNode(node, diseaseEntity, contains(diseaseEntity, lofInstances));
if (diseaseNode == null) continue; // Just in case
// Re-link to diseaseNode
ConnectInfo connectInfo = reactionCopy.getConnectInfo();
List<?> widgets = connectInfo.getConnectWidgets();
for (Object obj : widgets) {
ConnectWidget widget = (ConnectWidget) obj;
if (widget.getConnectedNode() == node) widget.replaceConnectedNode(diseaseNode);
}
}
} else overlaidObjects.add(node);
}
}
@Override
public boolean isDisplayable(GKInstance instance) {
if (!instance.getSchemClass().isa(ReactomeJavaConstants.PhysicalEntity)
|| instance.getSchemClass().isa(ReactomeJavaConstants.Complex)) return false;
return true;
}