@Override
public UpdateContainer doIt(Workspace workspace) throws CommandException {
UpdateContainer uc = new UpdateContainer();
SuperSelection sel = this.getSuperSelection(workspace);
for (int i = 0; i < updates.length(); i++) {
String update = updates.getString(i);
switch (update) {
case "headers":
uc.add(new WorksheetHeadersUpdate(worksheetId));
break;
case "list":
uc.add(new WorksheetListUpdate());
break;
case "data":
uc.add(new WorksheetDataUpdate(worksheetId, sel));
break;
case "alignment":
{
Alignment alignment =
AlignmentManager.Instance()
.getAlignmentOrCreateIt(
workspace.getId(), worksheetId, workspace.getOntologyManager());
uc.add(new AlignmentSVGVisualizationUpdate(worksheetId, alignment));
break;
}
case "semanticTypes":
{
Alignment alignment =
AlignmentManager.Instance()
.getAlignmentOrCreateIt(
workspace.getId(), worksheetId, workspace.getOntologyManager());
uc.add(
new SemanticTypesUpdate(
workspace.getWorksheet(worksheetId), worksheetId, alignment));
break;
}
case "regenerate":
uc.add(new RegenerateWorksheetUpdate(worksheetId));
break;
case "all":
uc = WorksheetUpdateFactory.createRegenerateWorksheetUpdates(worksheetId, sel);
break;
case "cleaning":
uc.add(new WorksheetCleaningUpdate(worksheetId, false, sel));
break;
}
}
return uc;
}
@Override
public void generateJson(String prefix, PrintWriter pw, VWorkspace vWorkspace) {
Workspace workspace = vWorkspace.getWorkspace();
alignment = AlignmentManager.Instance().getAlignment(workspace.getId(), worksheetId);
SemanticTypes types = worksheet.getSemanticTypes();
Map<String, ColumnNode> hNodeIdTocolumnNodeMap = createColumnNodeMap();
Map<String, SemanticTypeNode> hNodeIdToDomainNodeMap = createDomainNodeMap();
JSONStringer jsonStr = new JSONStringer();
try {
JSONWriter writer = jsonStr.object();
writer.key("worksheetId").value(worksheetId).key("updateType").value("SemanticTypesUpdate");
writer.key(JsonKeys.Types.name());
writer.array();
// Iterate through all the columns
for (HNodePath path : worksheet.getHeaders().getAllPaths()) {
HNode node = path.getLeaf();
String nodeId = node.getId();
writer.object();
// Check if a semantic type exists for the HNode
SemanticType type = types.getSemanticTypeForHNodeId(nodeId);
if (type != null && type.getConfidenceLevel() != SemanticType.ConfidenceLevel.Low) {
writer
.key(JsonKeys.HNodeId.name())
.value(type.getHNodeId())
.key(JsonKeys.SemanticTypesArray.name())
.array();
ColumnNode alignmentColumnNode = hNodeIdTocolumnNodeMap.get(type.getHNodeId());
SemanticTypeNode domainNode = hNodeIdToDomainNodeMap.get(type.getHNodeId());
if (alignmentColumnNode == null || domainNode == null) {
logger.error(
"Column node or domain node not found in alignment."
+ " (This should not happen conceptually!):"
+ type);
continue;
}
// Add the primary semantic type
writer
.object()
.key(JsonKeys.Origin.name())
.value(type.getOrigin().name())
.key(JsonKeys.ConfidenceLevel.name())
.value(type.getConfidenceLevel().name())
.key(JsonKeys.isPrimary.name())
.value(true);
// Add the RDF literal type to show in the text box
String rdfLiteralType =
alignmentColumnNode.getRdfLiteralType() == null
? ""
: alignmentColumnNode.getRdfLiteralType().getDisplayName();
String language =
alignmentColumnNode.getLanguage() == null ? "" : alignmentColumnNode.getLanguage();
writer.key(JsonKeys.rdfLiteralType.name()).value(rdfLiteralType);
writer.key(JsonKeys.language.name()).value(language);
// String domainDisplayLabel = (domainNode.getLabel().getPrefix() != null &&
// (!domainNode.getLabel().getPrefix().equals(""))) ?
// (domainNode.getLabel().getPrefix() + ":" + domainNode.getLocalId()) :
// domainNode.getLocalId();
if (!type.isClass()) {
writer
.key(JsonKeys.FullType.name())
.value(type.getType().getUri())
.key(JsonKeys.DisplayLabel.name())
.value(type.getType().getDisplayName())
.key(JsonKeys.DisplayRDFSLabel.name())
.value(type.getType().getRdfsLabel())
.key(JsonKeys.DisplayRDFSComment.name())
.value(type.getType().getRdfsComment())
.key(JsonKeys.DomainId.name())
.value(domainNode.getId())
.key(JsonKeys.DomainUri.name())
.value(domainNode.getUri())
.key(JsonKeys.DisplayDomainLabel.name())
.value(domainNode.getDisplayId())
.key(JsonKeys.DomainRDFSLabel.name())
.value(domainNode.getRdfsLabel())
.key(JsonKeys.DomainRDFSComment.name())
.value(domainNode.getRdfsComment());
} else {
writer
.key(JsonKeys.FullType.name())
.value(domainNode.getId())
.key(JsonKeys.DisplayLabel.name())
.value(domainNode.getDisplayId())
.key(JsonKeys.DisplayRDFSLabel.name())
.value(domainNode.getRdfsLabel())
.key(JsonKeys.DisplayRDFSComment.name())
.value(domainNode.getRdfsComment())
.key(JsonKeys.DomainId.name())
.value("")
.key(JsonKeys.DomainUri.name())
.value("")
.key(JsonKeys.DisplayDomainLabel.name())
.value("")
.key(JsonKeys.DomainRDFSLabel.name())
.value("")
.key(JsonKeys.DomainRDFSComment.name())
.value("");
}
// Mark the special properties
writer
.key(JsonKeys.isMetaProperty.name())
.value(isMetaProperty(type.getType(), alignmentColumnNode));
writer.endObject();
// Iterate through the synonym semantic types
SynonymSemanticTypes synTypes = types.getSynonymTypesForHNodeId(nodeId);
if (synTypes != null) {
for (SemanticType synType : synTypes.getSynonyms()) {
writer
.object()
.key(JsonKeys.HNodeId.name())
.value(synType.getHNodeId())
.key(JsonKeys.FullType.name())
.value(synType.getType().getUri())
.key(JsonKeys.Origin.name())
.value(synType.getOrigin().name())
.key(JsonKeys.ConfidenceLevel.name())
.value(synType.getConfidenceLevel().name())
.key(JsonKeys.DisplayLabel.name())
.value(synType.getType().getDisplayName())
.key(JsonKeys.DisplayRDFSLabel.name())
.value(synType.getType().getRdfsLabel())
.key(JsonKeys.DisplayRDFSComment.name())
.value(synType.getType().getRdfsComment())
.key(JsonKeys.isPrimary.name())
.value(false);
if (!synType.isClass()) {
writer
.key(JsonKeys.DomainUri.name())
.value(synType.getDomain().getUri())
.key(JsonKeys.DomainId.name())
.value("")
.key(JsonKeys.DisplayDomainLabel.name())
.value(synType.getDomain().getDisplayName())
.key(JsonKeys.DomainRDFSLabel.name())
.value(synType.getDomain().getRdfsLabel())
.key(JsonKeys.DomainRDFSComment.name())
.value(synType.getDomain().getRdfsComment());
} else {
writer
.key(JsonKeys.DomainId.name())
.value("")
.key(JsonKeys.DomainUri.name())
.value("")
.key(JsonKeys.DisplayDomainLabel.name())
.value("")
.key(JsonKeys.DomainRDFSLabel.name())
.value("")
.key(JsonKeys.DomainRDFSComment.name())
.value("");
}
writer.endObject();
}
}
writer.endArray();
} else {
writer.key(JsonKeys.HNodeId.name()).value(nodeId);
writer.key(JsonKeys.SemanticTypesArray.name()).array().endArray();
}
writer.endObject();
}
writer.endArray();
writer.endObject();
pw.print(writer.toString());
} catch (JSONException e) {
logger.error("Error occured while writing to JSON!", e);
}
}
@Override
public UpdateContainer doIt(Workspace workspace) throws CommandException {
ModelingConfiguration modelingConfiguration =
ModelingConfigurationRegistry.getInstance()
.getModelingConfiguration(
WorkspaceKarmaHomeRegistry.getInstance().getKarmaHome(workspace.getId()));
TripleStoreUtil utilObj = new TripleStoreUtil();
boolean showModelsWithoutMatching = modelingConfiguration.isShowModelsWithoutMatching();
try {
HashMap<String, List<String>> metadata =
utilObj.getMappingsWithMetadata(TripleStoreUrl, context);
RepFactory factory = workspace.getFactory();
List<String> model_Names = metadata.get("model_names");
List<String> model_Urls = metadata.get("model_urls");
List<String> model_Times = metadata.get("model_publishtimes");
List<String> model_Contexts = metadata.get("model_contexts");
List<String> model_inputColumns = metadata.get("model_inputcolumns");
final List<JSONObject> list = new ArrayList<>();
Set<String> worksheetcolumns = new HashSet<>();
if (worksheetId != null && !worksheetId.trim().isEmpty()) {
HTable htable = factory.getWorksheet(worksheetId).getHeaders();
getHNodesForWorksheet(htable, worksheetcolumns, factory);
}
Iterator<String> nameitr = model_Names.iterator();
Iterator<String> urlitr = model_Urls.iterator();
Iterator<String> timeitr = model_Times.iterator();
Iterator<String> contextitr = model_Contexts.iterator();
Iterator<String> inputitr = model_inputColumns.iterator();
while (nameitr.hasNext()
&& urlitr.hasNext()
&& timeitr.hasNext()
&& contextitr.hasNext()
&& inputitr.hasNext()) {
JSONObject obj = new JSONObject();
Set<String> inputs = new HashSet<>();
obj.put("name", nameitr.next());
obj.put("url", urlitr.next());
obj.put("publishTime", timeitr.next());
obj.put("context", contextitr.next());
String columns = inputitr.next();
if (columns != null && !columns.isEmpty()) {
JSONArray array = new JSONArray(columns);
for (int i = 0; i < array.length(); i++) inputs.add(array.get(i).toString());
} else if (showModelsWithoutMatching) {
list.add(obj);
}
if (worksheetId != null && !worksheetId.isEmpty()) {
inputs.retainAll(worksheetcolumns);
obj.put("inputColumns", inputs.size());
} else obj.put("inputColumns", 0);
if (!inputs.isEmpty() || (worksheetId == null || worksheetId.trim().isEmpty()))
list.add(obj);
}
Collections.sort(
list,
new Comparator<JSONObject>() {
@Override
public int compare(JSONObject a, JSONObject b) {
return b.getInt("inputColumns") - a.getInt("inputColumns");
}
});
return new UpdateContainer(
new AbstractUpdate() {
@Override
public void generateJson(String prefix, PrintWriter pw, VWorkspace vWorkspace) {
try {
JSONArray array = new JSONArray();
for (JSONObject obj : list) {
array.put(obj);
}
pw.print(array.toString());
} catch (Exception e) {
logger.error("Error generating JSON!", e);
}
}
});
} catch (Exception e) {
return new UpdateContainer(
new ErrorUpdate("Unable to get mappings with metadata: " + e.getMessage()));
}
}
@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;
}
