private Map<String, SemanticTypeNode> createDomainNodeMap() {
Map<String, SemanticTypeNode> hNodeIdToDomainNodeMap = new HashMap<>();
Set<Node> alignmentColumnNodes = alignment.getNodesByType(NodeType.ColumnNode);
if (alignmentColumnNodes == null) return hNodeIdToDomainNodeMap;
for (Node cNode : alignmentColumnNodes) {
Set<LabeledLink> incomingLinks = alignment.getCurrentIncomingLinksToNode(cNode.getId());
if (incomingLinks != null && !incomingLinks.isEmpty()) {
LabeledLink incomingLink =
alignment.getCurrentIncomingLinksToNode(cNode.getId()).iterator().next();
if (incomingLink != null && incomingLink.getSource() instanceof InternalNode) {
String hNodeId = ((ColumnNode) cNode).getHNodeId();
if (incomingLink instanceof DataPropertyOfColumnLink
|| incomingLink instanceof ObjectPropertySpecializationLink) {
String id;
if (incomingLink instanceof DataPropertyOfColumnLink)
id = ((DataPropertyOfColumnLink) incomingLink).getSpecializedLinkId();
else id = ((ObjectPropertySpecializationLink) incomingLink).getSpecializedLinkId();
hNodeIdToDomainNodeMap.put(
hNodeId,
new SemanticTypeNode(
id,
id,
id,
incomingLink.getLabel().getRdfsLabel(),
incomingLink.getLabel().getRdfsComment()));
} else {
InternalNode source = (InternalNode) incomingLink.getSource();
hNodeIdToDomainNodeMap.put(
hNodeId,
new SemanticTypeNode(
source.getId(),
source.getUri(),
source.getDisplayId(),
source.getLabel().getRdfsLabel(),
source.getLabel().getRdfsComment()));
}
}
}
}
return hNodeIdToDomainNodeMap;
}
private Set<SemanticTypeMapping> findSemanticTypeInGraph(
ColumnNode sourceColumn,
SemanticType semanticType,
HashMap<String, Integer> semanticTypesCount,
Set<Node> addedNodes) {
logger.debug("finding matches for semantic type in the graph ... ");
if (addedNodes == null) addedNodes = new HashSet<Node>();
Set<SemanticTypeMapping> mappings = new HashSet<SemanticTypeMapping>();
if (semanticType == null) {
logger.error("semantic type is null.");
return mappings;
}
if (semanticType.getDomain() == null) {
logger.error("semantic type does not have any domain");
return mappings;
}
if (semanticType.getType() == null) {
logger.error("semantic type does not have any link");
return mappings;
}
String domainUri = semanticType.getDomain().getUri();
String propertyUri = semanticType.getType().getUri();
Double confidence = semanticType.getConfidenceScore();
Origin origin = semanticType.getOrigin();
Integer countOfSemanticType = semanticTypesCount.get(domainUri + propertyUri);
if (countOfSemanticType == null) {
logger.error("count of semantic type should not be null or zero");
return mappings;
}
if (domainUri == null || domainUri.isEmpty()) {
logger.error("semantic type does not have any domain");
return mappings;
}
if (propertyUri == null || propertyUri.isEmpty()) {
logger.error("semantic type does not have any link");
return mappings;
}
logger.debug(
"semantic type: " + domainUri + "|" + propertyUri + "|" + confidence + "|" + origin);
// add dataproperty to existing classes if sl is a data node mapping
// Set<Node> foundInternalNodes = new HashSet<Node>();
Set<SemanticTypeMapping> semanticTypeMatches =
this.graphBuilder.getSemanticTypeMatches().get(domainUri + propertyUri);
if (semanticTypeMatches != null) {
for (SemanticTypeMapping stm : semanticTypeMatches) {
SemanticTypeMapping mp =
new SemanticTypeMapping(
sourceColumn, semanticType, stm.getSource(), stm.getLink(), stm.getTarget());
mappings.add(mp);
// foundInternalNodes.add(stm.getSource());
}
}
logger.debug("adding data property to the found internal nodes ...");
Integer count;
boolean allowMultipleSamePropertiesPerNode =
ModelingConfigurationRegistry.getInstance()
.getModelingConfiguration(
ContextParametersRegistry.getInstance()
.getContextParameters(ontologyManager.getContextId())
.getKarmaHome())
.isMultipleSamePropertyPerNode();
Set<Node> nodesWithSameUriOfDomain = this.graphBuilder.getUriToNodesMap().get(domainUri);
if (nodesWithSameUriOfDomain != null) {
for (Node source : nodesWithSameUriOfDomain) {
count = this.graphBuilder.getNodeDataPropertyCount().get(source.getId() + propertyUri);
if (count != null) {
if (allowMultipleSamePropertiesPerNode) {
if (count >= countOfSemanticType.intValue()) continue;
} else {
if (count >= 1) continue;
}
}
String nodeId = new RandomGUID().toString();
ColumnNode target = new ColumnNode(nodeId, nodeId, sourceColumn.getColumnName(), null);
if (!this.graphBuilder.addNode(target)) continue;
;
addedNodes.add(target);
String linkId = LinkIdFactory.getLinkId(propertyUri, source.getId(), target.getId());
LabeledLink link = new DataPropertyLink(linkId, new Label(propertyUri));
if (!this.graphBuilder.addLink(source, target, link)) continue;
;
SemanticTypeMapping mp =
new SemanticTypeMapping(
sourceColumn, semanticType, (InternalNode) source, link, target);
mappings.add(mp);
}
}
return mappings;
}
@Override
public void generateJson(String prefix, PrintWriter pw, VWorkspace vWorkspace) {
VWorksheet vWorksheet = vWorkspace.getViewFactory().getVWorksheetByWorksheetId(worksheetId);
List<String> hNodeIdList = new ArrayList<String>();
List<HNodePath> columns = vWorksheet.getColumns();
for (HNodePath path : columns) hNodeIdList.add(path.getLeaf().getId());
String alignmentId =
AlignmentManager.Instance()
.constructAlignmentId(vWorkspace.getWorkspace().getId(), vWorksheet.getWorksheetId());
JSONObject topObj = new JSONObject();
try {
topObj.put(
GenericJsonKeys.updateType.name(), AlignmentSVGVisualizationUpdate.class.getSimpleName());
topObj.put(JsonKeys.alignmentId.name(), alignmentId);
topObj.put(JsonKeys.worksheetId.name(), worksheetId);
// Using Mohsen's GraphUtils method for graph traversal
HashMap<Node, Integer> nodeHeightsMap = GraphUtil.levelingCyclicGraph(alignmentGraph);
HashMap<Node, Set<ColumnNode>> nodeCoverage =
GraphUtil.getNodesCoverage(alignmentGraph, nodeHeightsMap);
/** Identify the max height * */
int maxTreeHeight = 0;
for (Node node : nodeHeightsMap.keySet()) {
if (nodeHeightsMap.get(node) >= maxTreeHeight) {
maxTreeHeight = nodeHeightsMap.get(node);
}
}
/** * Add the nodes and the links from the Steiner tree ** */
List<String> hNodeIdsAdded = new ArrayList<String>();
JSONArray nodesArr = new JSONArray();
JSONArray linksArr = new JSONArray();
if (alignmentGraph != null && alignmentGraph.vertexSet().size() != 0) {
/** Add the nodes * */
Set<Node> nodes = alignmentGraph.vertexSet();
HashMap<Node, Integer> verticesIndex = new HashMap<Node, Integer>();
int nodesIndexcounter = 0;
for (Node node : nodes) {
/** Get info about the nodes that this node covers or sits above * */
int height = maxTreeHeight - nodeHeightsMap.get(node);
/** Add the hnode ids of the columns that this vertex covers * */
JSONArray hNodeIdsCoveredByVertex = new JSONArray();
for (Node v : nodeCoverage.get(node)) {
if (v instanceof ColumnNode) {
ColumnNode cNode = (ColumnNode) v;
hNodeIdsCoveredByVertex.put(cNode.getHNodeId());
}
}
String hNodeId = "";
/** Add the semantic type information * */
if (node instanceof ColumnNode) {
ColumnNode cNode = (ColumnNode) node;
hNodeId = cNode.getHNodeId();
hNodeIdsAdded.add(cNode.getHNodeId());
}
JSONObject nodeObj =
getNodeJsonObject(
node.getLocalId(),
node.getId(),
node.getType().name(),
height,
hNodeIdsCoveredByVertex,
hNodeId);
nodesArr.put(nodeObj);
verticesIndex.put(node, nodesIndexcounter++);
}
/** * Add the links ** */
Set<Link> links = alignmentGraph.edgeSet();
for (Link link : links) {
Node source = link.getSource();
Integer sourceIndex = verticesIndex.get(source);
Node target = link.getTarget();
Integer targetIndex = verticesIndex.get(target);
Set<Link> outEdges = alignmentGraph.outgoingEdgesOf(target);
if (sourceIndex == null || targetIndex == null) {
logger.error("Edge vertex index not found!");
continue;
}
JSONObject linkObj = new JSONObject();
linkObj.put(JsonKeys.source.name(), sourceIndex);
linkObj.put(JsonKeys.target.name(), targetIndex);
linkObj.put(JsonKeys.sourceNodeId.name(), source.getId());
linkObj.put(JsonKeys.targetNodeId.name(), target.getId());
linkObj.put(JsonKeys.label.name(), link.getLabel().getLocalName());
linkObj.put(JsonKeys.id.name(), link.getId() + "");
linkObj.put(JsonKeys.linkStatus.name(), link.getStatus().name());
linkObj.put(JsonKeys.linkUri.name(), link.getLabel().getUri());
if (target.getType() == NodeType.ColumnNode && outEdges.isEmpty()) {
linkObj.put(JsonKeys.linkType.name(), JsonValues.holderLink.name());
if (link.getKeyType() == LinkKeyInfo.PartOfKey)
linkObj.put(JsonKeys.label.name(), link.getLabel().getLocalName() + "*");
}
linksArr.put(linkObj);
if (link.getType() == LinkType.ClassInstanceLink
&& link.getKeyType() == LinkKeyInfo.PartOfKey
&& target instanceof ColumnNode) {
ColumnNode cNode = (ColumnNode) target;
// Add the holder vertex object and the link that attaches nodes to the columns
JSONArray hNodeIdsCoveredByVertex_holder = new JSONArray();
hNodeIdsCoveredByVertex_holder.put(cNode.getHNodeId());
JSONObject vertObj_holder =
getNodeJsonObject(
JsonValues.key.name(),
source.getId() + "_holder",
NodeType.ColumnNode.name(),
0,
hNodeIdsCoveredByVertex_holder,
cNode.getHNodeId());
nodesArr.put(vertObj_holder);
nodesIndexcounter++;
// Add the holder link
JSONObject linkObj_holder =
getLinkJsonObject(
JsonValues.key.name(),
"",
nodesIndexcounter,
nodesIndexcounter - 1,
"",
"",
"",
"");
linksArr.put(linkObj_holder);
}
if (link.getType() == LinkType.DataPropertyOfColumnLink) {
DataPropertyOfColumnLink dpLink = (DataPropertyOfColumnLink) link;
String startHNodeId = dpLink.getSpecializedColumnHNodeId();
// Get height of the class instance node
int height = maxTreeHeight - nodeHeightsMap.get(link.getSource());
// Add 2 more holder nodes
// Start node
JSONArray hNodeIdsCoveredByVertex_holder = new JSONArray();
hNodeIdsCoveredByVertex_holder.put(startHNodeId);
JSONObject startNode =
getNodeJsonObject(
"",
source.getId() + "_holder",
JsonValues.DataPropertyOfColumnHolder.name(),
height - 0.35,
hNodeIdsCoveredByVertex_holder,
startHNodeId);
nodesArr.put(startNode);
nodesIndexcounter++;
// End node
String endHNodeId = ((ColumnNode) link.getTarget()).getHNodeId();
JSONArray hNodeIdsCoveredByVertex_holder_2 = new JSONArray();
hNodeIdsCoveredByVertex_holder_2.put(endHNodeId);
JSONObject endNode =
getNodeJsonObject(
"",
target.getId() + "_holder",
JsonValues.DataPropertyOfColumnHolder.name(),
height - 0.35,
hNodeIdsCoveredByVertex_holder_2,
endHNodeId);
nodesArr.put(endNode);
nodesIndexcounter++;
// Add the horizontal link
JSONObject linkObj_holder =
getLinkJsonObject(
"",
"",
nodesIndexcounter - 2,
nodesIndexcounter - 1,
JsonValues.horizontalDataPropertyLink.name(),
"",
"",
"");
linksArr.put(linkObj_holder);
} else if (link.getType() == LinkType.ObjectPropertySpecializationLink) {
ObjectPropertySpecializationLink opLink = (ObjectPropertySpecializationLink) link;
Link specializedLink = opLink.getSpecializedLink();
// Get height of the class instance node
int height = nodeHeightsMap.get(specializedLink.getTarget());
// Add 2 more holder nodes
// Start node
JSONArray hNodeIdsCoveredByVertex_holder = new JSONArray();
for (Node v : nodeCoverage.get(specializedLink.getTarget())) {
if (v instanceof ColumnNode) {
ColumnNode cNode = (ColumnNode) v;
hNodeIdsCoveredByVertex_holder.put(cNode.getHNodeId());
}
}
JSONObject startNode =
getNodeJsonObject(
"",
source.getId() + "_holder",
JsonValues.DataPropertyOfColumnHolder.name(),
height + 0.65,
hNodeIdsCoveredByVertex_holder,
"");
nodesArr.put(startNode);
nodesIndexcounter++;
// End node
String endHNodeId = ((ColumnNode) link.getTarget()).getHNodeId();
JSONArray hNodeIdsCoveredByVertex_holder_2 = new JSONArray();
hNodeIdsCoveredByVertex_holder_2.put(endHNodeId);
JSONObject endNode =
getNodeJsonObject(
"",
target.getId() + "_holder",
JsonValues.DataPropertyOfColumnHolder.name(),
height + 0.65,
hNodeIdsCoveredByVertex_holder_2,
endHNodeId);
nodesArr.put(endNode);
nodesIndexcounter++;
// Add the horizontal link
JSONObject linkObj_holder =
getLinkJsonObject(
"",
"",
nodesIndexcounter - 2,
nodesIndexcounter - 1,
JsonValues.horizontalDataPropertyLink.name(),
"",
"",
"");
linksArr.put(linkObj_holder);
}
linkObj.put(JsonKeys.linkType.name(), link.getType());
}
}
// Add the vertices for the columns that were not in Steiner tree
hNodeIdList.removeAll(hNodeIdsAdded);
for (String hNodeId : hNodeIdList) {
JSONArray hNodeIdsCoveredByVertex = new JSONArray();
hNodeIdsCoveredByVertex.put(hNodeId);
JSONObject vertObj =
getNodeJsonObject(
"", hNodeId, JsonValues.Unassigned.name(), 0, hNodeIdsCoveredByVertex, hNodeId);
nodesArr.put(vertObj);
}
topObj.put(JsonKeys.maxTreeHeight.name(), maxTreeHeight);
topObj.put(JsonKeys.nodes.name(), nodesArr);
topObj.put(JsonKeys.links.name(), linksArr);
pw.write(topObj.toString());
} catch (JSONException e) {
logger.error("Error occured while writing JSON!", e);
}
}
private static DirectedWeightedMultigraph<Node, LabeledLink> buildGraphsFromStatements2(
List<Statement> statements) {
if (statements == null || statements.size() == 0) return null;
DirectedWeightedMultigraph<Node, LabeledLink> graph =
new DirectedWeightedMultigraph<Node, LabeledLink>(LabeledLink.class);
// Assumption: there is only one rdf:type for each URI
HashMap<String, Node> uri2Classes = new HashMap<String, Node>();
for (Statement st : statements) {
String subjStr = st.getSubject();
String predicateStr = st.getPredicate();
String objStr = st.getObject();
subjStr = getUri(subjStr);
predicateStr = getUri(predicateStr);
objStr = getUri(objStr);
if (predicateStr.equalsIgnoreCase(typePredicate)) {
Node classNode = new InternalNode(objStr, new Label(objStr));
uri2Classes.put(subjStr, classNode);
graph.addVertex(classNode);
}
}
// int countOfLiterals = 0;
String id;
for (Statement st : statements) {
String subjStr = st.getSubject();
String predicateStr = st.getPredicate();
String objStr = st.getObject();
subjStr = getUri(subjStr);
predicateStr = getUri(predicateStr);
objStr = getUri(objStr);
if (predicateStr.equalsIgnoreCase(typePredicate)) continue;
Node subj = uri2Classes.get(subjStr);
if (subj == null) {
subj = new InternalNode(subjStr, new Label(subjStr));
graph.addVertex(subj);
}
Node obj = uri2Classes.get(objStr);
if (obj == null) {
if (objStr.startsWith(attPrefix)) {
id = new RandomGUID().toString();
obj = new ColumnNode(id, objStr, objStr, null, null);
SemanticType semanticType =
new SemanticType(
((ColumnNode) obj).getHNodeId(),
new Label(predicateStr),
subj.getLabel(),
Origin.User,
1.0,
false);
((ColumnNode) obj).setUserSelectedSemanticType(semanticType);
} else if (objStr.indexOf(":") == -1 && objStr.indexOf("\"") != -1) {
// String literalId = "lit:" + serviceId + "_l" + String.valueOf(countOfLiterals);
obj = new LiteralNode(objStr, objStr, null);
// countOfLiterals ++;
} else obj = new InternalNode(objStr, new Label(objStr));
graph.addVertex(obj);
}
LabeledLink e;
if (obj instanceof InternalNode)
e =
new ObjectPropertyLink(
LinkIdFactory.getLinkId(predicateStr, subj.getId(), obj.getId()),
new Label(predicateStr),
ObjectPropertyType.None);
else
e =
new DataPropertyLink(
LinkIdFactory.getLinkId(predicateStr, subj.getId(), obj.getId()),
new Label(predicateStr));
graph.addEdge(subj, obj, e);
}
return graph;
}
@Override
public UpdateContainer doIt(Workspace workspace) throws CommandException {
final OntologyManager ontMgr = workspace.getOntologyManager();
Set<LabeledLink> properties = new HashSet<>();
logger.debug(
"GetPropertiesCommand:"
+ propertiesRange
+ ":"
+ classURI
+ ","
+ domainURI
+ ", "
+ rangeURI);
if (propertiesRange == INTERNAL_PROP_RANGE.allObjectProperties) {
HashMap<String, Label> linkList = ontMgr.getObjectProperties();
if (linkList != null) {
for (Label label : linkList.values()) {
properties.add(new DataPropertyLink(label.getUri(), label));
}
}
} else if (propertiesRange == INTERNAL_PROP_RANGE.allDataProperties) {
HashMap<String, Label> linkList = ontMgr.getDataProperties();
for (Label label : linkList.values()) {
properties.add(new DataPropertyLink(label.getUri(), label));
}
} else if (propertiesRange == INTERNAL_PROP_RANGE.propertiesWithDomainRange) {
Map<String, Label> linkList =
ontMgr.getObjectPropertiesByDomainRange(domainURI, rangeURI, true);
for (Label label : linkList.values()) {
properties.add(new DataPropertyLink(label.getUri(), label));
}
} else if (propertiesRange == INTERNAL_PROP_RANGE.dataPropertiesForClass) {
Map<String, Label> linkList = ontMgr.getDataPropertiesByDomain(classURI, true);
for (Label label : linkList.values()) {
properties.add(new DataPropertyLink(label.getUri(), label));
}
} else if (propertiesRange == INTERNAL_PROP_RANGE.existingProperties) {
Alignment alignment =
AlignmentManager.Instance()
.getAlignmentOrCreateIt(workspace.getId(), worksheetId, ontMgr);
Set<String> steinerTreeNodeIds = new HashSet<String>();
if (alignment != null && !alignment.isEmpty()) {
DirectedWeightedMultigraph<Node, LabeledLink> steinerTree = alignment.getSteinerTree();
for (Node node : steinerTree.vertexSet()) {
if (node.getType() == NodeType.InternalNode) {
steinerTreeNodeIds.add(node.getId());
}
}
List<LabeledLink> specializedLinks = new ArrayList<LabeledLink>();
Set<LabeledLink> temp = null;
temp = alignment.getLinksByType(LinkType.DataPropertyLink);
if (temp != null) specializedLinks.addAll(temp);
for (LabeledLink link : steinerTree.edgeSet())
if (link instanceof ObjectPropertyLink) specializedLinks.add(link);
// Store the data property links for specialized edge link options
properties.addAll(specializedLinks);
}
}
logger.debug("Got back " + properties.size() + " results");
final Set<LabeledLink> finalProperties = properties;
UpdateContainer upd =
new UpdateContainer(
new AbstractUpdate() {
@Override
public void generateJson(String prefix, PrintWriter pw, VWorkspace vWorkspace) {
JSONObject obj = new JSONObject();
JSONArray resultArray = new JSONArray();
try {
obj.put(JsonKeys.updateType.name(), "PropertyList");
for (LabeledLink link : finalProperties) {
Label linkLabel = link.getLabel();
String edgeLabelStr = linkLabel.getDisplayName();
JSONObject edgeObj = new JSONObject();
if (linkLabel.getUri() != null
&& linkLabel.getNs() != null
&& linkLabel.getUri().equalsIgnoreCase(linkLabel.getNs())) {
edgeLabelStr = linkLabel.getUri();
}
edgeObj.put(JsonKeys.label.name(), edgeLabelStr);
edgeObj.put(JsonKeys.uri.name(), linkLabel.getUri());
edgeObj.put(JsonKeys.id.name(), link.getId());
resultArray.put(edgeObj);
}
obj.put(JsonKeys.properties.name(), resultArray);
pw.println(obj.toString());
} catch (Exception e) {
logger.error("Exception:", e);
e.printStackTrace();
}
}
});
return upd;
}