@Override
public UpdateContainer doIt(Workspace workspace) throws CommandException {
Worksheet wk = workspace.getWorksheet(worksheetId);
SuperSelection selection = getSuperSelection(wk);
String Msg =
String.format("begin, Time,%d, Worksheet,%s", System.currentTimeMillis(), worksheetId);
logger.info(Msg);
// Get the HNode
HashMap<String, HashMap<String, String>> rows = new HashMap<String, HashMap<String, String>>();
HNodePath selectedPath = null;
List<HNodePath> columnPaths = wk.getHeaders().getAllPaths();
for (HNodePath path : columnPaths) {
if (path.getLeaf().getId().equals(hNodeId)) {
selectedPath = path;
}
}
// random nodes
Collection<Node> nodes = new ArrayList<Node>();
wk.getDataTable().collectNodes(selectedPath, nodes, selection);
HashSet<Integer> indSet = this.obtainIndexs(nodes.size());
int index = 0;
for (Iterator<Node> iterator = nodes.iterator(); iterator.hasNext(); ) {
Node node = iterator.next();
if (indSet.contains(index)) {
String id = node.getId();
String originalVal = node.getValue().asString();
HashMap<String, String> x = new HashMap<String, String>();
x.put("Org", originalVal);
x.put("Tar", originalVal);
x.put("Orgdis", originalVal);
x.put("Tardis", originalVal);
rows.put(id, x);
}
index++;
}
Msg = String.format("end, Time,%d, Worksheet,%s", System.currentTimeMillis(), worksheetId);
logger.info(Msg);
return new UpdateContainer(new FetchResultUpdate(hNodeId, rows));
}
@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);
}
}
public void run() {
long start = System.currentTimeMillis();
// Find the corresponding hNodePath. Used to find examples for training the CRF Model.
HNodePath currentColumnPath = null;
List<HNodePath> paths = worksheet.getHeaders().getAllPaths();
for (HNodePath path : paths) {
if (path.getLeaf().getId().equals(newType.getHNodeId())) {
currentColumnPath = path;
break;
}
}
Map<ColumnFeature, Collection<String>> columnFeatures =
new HashMap<ColumnFeature, Collection<String>>();
// Prepare the column name for training
String columnName = currentColumnPath.getLeaf().getColumnName();
Collection<String> columnNameList = new ArrayList<String>();
columnNameList.add(columnName);
columnFeatures.put(ColumnFeature.ColumnHeaderName, columnNameList);
// Train the model with the new type
ArrayList<String> trainingExamples =
SemanticTypeUtil.getTrainingExamples(worksheet, currentColumnPath);
boolean trainingResult = false;
String newTypeString =
(newType.getDomain() == null)
? newType.getType().getUri()
: newType.getDomain().getUri() + "|" + newType.getType().getUri();
trainingResult =
crfModelHandler.addOrUpdateLabel(newTypeString, trainingExamples, columnFeatures);
if (!trainingResult) {
logger.error("Error occured while training CRF Model.");
}
// logger.debug("Using type:" + newType.getDomain().getUri() + "|" +
// newType.getType().getUri());
// Add the new CRF column model for this column
ArrayList<String> labels = new ArrayList<String>();
ArrayList<Double> scores = new ArrayList<Double>();
trainingResult =
crfModelHandler.predictLabelForExamples(
trainingExamples, 4, labels, scores, null, columnFeatures);
if (!trainingResult) {
logger.error("Error occured while predicting labels");
}
CRFColumnModel newModel = new CRFColumnModel(labels, scores);
worksheet.getCrfModel().addColumnModel(newType.getHNodeId(), newModel);
long elapsedTimeMillis = System.currentTimeMillis() - start;
float elapsedTimeSec = elapsedTimeMillis / 1000F;
logger.info("Time required for training the semantic type: " + elapsedTimeSec);
// long t2 = System.currentTimeMillis();
// Identify the outliers for the column
// SemanticTypeUtil.identifyOutliers(worksheet, newTypeString,currentColumnPath,
// vWorkspace.getWorkspace().getTagsContainer()
// .getTag(TagName.Outlier), columnFeatures, crfModelHandler);
// long t3 = System.currentTimeMillis();
// logger.info("Identify outliers: "+ (t3-t2));
}
@Override
public UpdateContainer doIt(Workspace workspace) throws CommandException {
Worksheet wk = workspace.getWorksheet(worksheetId);
SuperSelection selection = getSuperSelection(wk);
String msg =
String.format(
"Gen rule start,Time,%d, Worksheet,%s", System.currentTimeMillis(), worksheetId);
logger.info(msg);
// Get the HNode
HashMap<String, String> rows = new HashMap<String, String>();
HashMap<String, Integer> amb = new HashMap<String, Integer>();
HNodePath selectedPath = null;
List<HNodePath> columnPaths = wk.getHeaders().getAllPaths();
for (HNodePath path : columnPaths) {
if (path.getLeaf().getId().equals(hNodeId)) {
selectedPath = path;
}
}
Collection<Node> nodes = new ArrayList<Node>();
wk.getDataTable().collectNodes(selectedPath, nodes, selection);
for (Node node : nodes) {
String id = node.getId();
if (!this.nodeIds.contains(id)) continue;
String originalVal = node.getValue().asString();
rows.put(id, originalVal);
this.compResultString += originalVal + "\n";
calAmbScore(id, originalVal, amb);
}
RamblerValueCollection vc = new RamblerValueCollection(rows);
HashMap<String, Vector<String[]>> expFeData = new HashMap<String, Vector<String[]>>();
inputs = new RamblerTransformationInputs(examples, vc);
// generate the program
boolean results = false;
int iterNum = 0;
RamblerTransformationOutput rtf = null;
// initialize the vocabulary
Iterator<String> iterx = inputs.getInputValues().getValues().iterator();
Vector<String> v = new Vector<String>();
int vb_cnt = 0;
while (iterx.hasNext() && vb_cnt < 30) {
String eString = iterx.next();
v.add(eString);
vb_cnt++;
}
Vector<String> vob = UtilTools.buildDict(v);
inputs.setVocab(vob.toArray(new String[vob.size()]));
while (iterNum < 1 && !results) // try to find an program within iterNum
{
rtf = new RamblerTransformationOutput(inputs);
if (rtf.getTransformations().keySet().size() > 0) {
results = true;
}
iterNum++;
}
Iterator<String> iter = rtf.getTransformations().keySet().iterator();
// id:{org: tar: orgdis: tardis: }
HashMap<String, HashMap<String, String>> resdata =
new HashMap<String, HashMap<String, String>>();
HashSet<String> keys = new HashSet<String>();
while (iter.hasNext()) {
String tpid = iter.next();
ValueCollection rvco = rtf.getTransformedValues_debug(tpid);
if (rvco == null) continue;
// constructing displaying data
HashMap<String, String[]> xyzHashMap = new HashMap<String, String[]>();
for (String key : rvco.getNodeIDs()) {
HashMap<String, String> dict = new HashMap<String, String>();
// add to the example selection
boolean isExp = false;
String org = vc.getValue(key);
String classLabel = rvco.getClass(key);
String pretar = rvco.getValue(key);
String dummyValue = pretar;
if (pretar.indexOf("_FATAL_ERROR_") != -1) {
dummyValue = org;
// dummyValue = "#ERROR";
}
try {
UtilTools.StringColorCode(org, dummyValue, dict);
} catch (Exception ex) {
logger.info(String.format("ColorCoding Exception%s, %s", org, dummyValue));
// set dict
dict.put("Org", org);
dict.put("Tar", "ERROR");
dict.put("Orgdis", org);
dict.put("Tardis", "ERROR");
}
for (TransformationExample exp : examples) {
if (exp.getNodeId().compareTo(key) == 0) {
if (!expFeData.containsKey(classLabel)) {
Vector<String[]> vstr = new Vector<String[]>();
String[] texp = {dict.get("Org"), pretar};
vstr.add(texp);
expFeData.put(classLabel, vstr);
} else {
String[] texp = {dict.get("Org"), pretar};
expFeData.get(classLabel).add(texp);
}
isExp = true;
}
}
if (!isExp) {
String[] pair = {dict.get("Org"), dict.get("Tar"), pretar, classLabel};
xyzHashMap.put(key, pair);
}
resdata.put(key, dict);
}
if (!rtf.nullRule) keys.add(getBestExample(xyzHashMap, expFeData));
}
// find the best row
String vars = "";
String expstr = "";
String recmd = "";
for (TransformationExample x : examples) {
expstr += String.format("%s|%s", x.getBefore(), x.getAfter());
}
expstr += "|";
if (rtf.nullRule) {
keys.clear();
// keys.add("-2"); // "-2 indicates null rule"
}
if (!resdata.isEmpty() && !rtf.nullRule) {
recmd = resdata.get(keys.iterator().next()).get("Org");
} else {
recmd = "";
}
msg =
String.format(
"Gen rule end, Time,%d, Worksheet,%s,Examples:%s,Recmd:%s",
System.currentTimeMillis(), worksheetId, expstr, recmd);
logger.info(msg);
return new UpdateContainer(new CleaningResultUpdate(hNodeId, resdata, vars, keys));
}
@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);
}
}
@Override
public UpdateContainer doIt(Workspace workspace) throws CommandException {
Worksheet worksheet = workspace.getWorksheet(worksheetId);
SuperSelection selection = getSuperSelection(worksheet);
HNodePath selectedPath = null;
List<HNodePath> columnPaths = worksheet.getHeaders().getAllPaths();
for (HNodePath path : columnPaths) {
if (path.getLeaf().getId().equals(hNodeId)) {
selectedPath = path;
}
}
Collection<Node> nodes = new ArrayList<Node>();
workspace
.getFactory()
.getWorksheet(worksheetId)
.getDataTable()
.collectNodes(selectedPath, nodes, selection);
try {
JSONArray requestJsonArray = new JSONArray();
for (Node node : nodes) {
String id = node.getId();
String originalVal = node.getValue().asString();
JSONObject jsonRecord = new JSONObject();
jsonRecord.put("id", id);
originalVal = originalVal == null ? "" : originalVal;
jsonRecord.put("value", originalVal);
requestJsonArray.put(jsonRecord);
}
String jsonString = null;
jsonString = requestJsonArray.toString();
// String url =
// "http://localhost:8080/cleaningService/IdentifyData";
// String url = "http://localhost:8070/myWS/IdentifyData";
String url =
ServletContextParameterMap.getParameterValue(ContextParameter.CLEANING_SERVICE_URL);
HttpClient httpclient = new DefaultHttpClient();
HttpPost httppost = null;
HttpResponse response = null;
HttpEntity entity;
StringBuffer out = new StringBuffer();
URI u = null;
u = new URI(url);
List<NameValuePair> formparams = new ArrayList<NameValuePair>();
formparams.add(new BasicNameValuePair("json", jsonString));
httppost = new HttpPost(u);
httppost.setEntity(new UrlEncodedFormEntity(formparams, "UTF-8"));
response = httpclient.execute(httppost);
entity = response.getEntity();
if (entity != null) {
BufferedReader buf = new BufferedReader(new InputStreamReader(entity.getContent()));
String line = buf.readLine();
while (line != null) {
out.append(line);
line = buf.readLine();
}
}
// logger.trace(out.toString());
// logger.info("Connnection success : " + url + " Successful.");
final JSONObject data1 = new JSONObject(out.toString());
// logger.trace("Data--->" + data1);
return new UpdateContainer(
new AbstractUpdate() {
@Override
public void generateJson(String prefix, PrintWriter pw, VWorkspace vWorkspace) {
JSONObject response = new JSONObject();
// logger.trace("Reached here");
try {
response.put("updateType", "CleaningServiceOutput");
response.put("chartData", data1);
response.put("hNodeId", hNodeId);
// logger.trace(response.toString(4));
} catch (JSONException e) {
pw.print("Error");
}
pw.print(response.toString());
}
});
} catch (Exception e) {
e.printStackTrace();
return new UpdateContainer(new ErrorUpdate("Error!"));
}
}