/** 打开查询结果 */
public static String[] openQuery(Hashtable params) {
JParamObject PO = new JParamObject();
for (Enumeration e = params.keys(); e.hasMoreElements(); ) {
String key = (String) e.nextElement();
String val = (String) params.get(key);
PO.SetValueByParamName(key, val);
}
String[] queryResult = new String[2];
JResponseObject RO =
(JResponseObject)
JActiveDComDM.AbstractDataActiveFramework.InvokeObjectMethod(
"DataReport", "OpenQuery", PO, "");
String XMLStr = (String) RO.ResponseObject;
if (RO != null && RO.ResponseObject != null) {
XMLStr = (String) RO.ResponseObject;
JXMLBaseObject XMLObj = new JXMLBaseObject(XMLStr);
Element queryElmt = XMLObj.GetElementByName("Query");
// 格式
queryResult[0] = queryElmt.getAttributeValue("QueryFormat");
// 数据
queryResult[0] = queryElmt.getAttributeValue("QueryData");
}
return queryResult;
}
public boolean load() {
try {
if (new File(FILE_PATH).exists()) {
FileInputStream FIS = new FileInputStream(FILE_PATH);
JXMLBaseObject cobjXmlObj = new JXMLBaseObject();
cobjXmlObj.InitXMLStream(FIS);
FIS.close();
Vector exps = new Vector();
Element rootElmt = cobjXmlObj.GetElementByName(JCStoreTableModel.ROOT_NAME);
for (Iterator i = rootElmt.getChildren().iterator(); i.hasNext(); ) {
Element crtElmt = (Element) i.next();
JCExpression exp = new JCExpression();
exp.mId = crtElmt.getAttributeValue("id", "");
exp.mName = crtElmt.getAttributeValue("name", "");
exp.mShowValue = crtElmt.getAttributeValue("show", "");
exp.mStoreValue = crtElmt.getAttributeValue("store", "");
exps.add(exp);
}
if (mModel != null) {
mModel.setExpression(exps);
}
}
} catch (Exception e) {
e.printStackTrace();
return false;
}
return true;
}
public ParseDoc(Object xmlFile, String rootId, TreeMap prevIdMap) {
SAXBuilder saxBuilder = new SAXBuilder();
try {
if (xmlFile instanceof String) {
document = saxBuilder.build((String) xmlFile);
} else if (xmlFile instanceof URL) {
document = saxBuilder.build((URL) xmlFile);
}
root = ParseUtils.parseRoot(document, rootId);
objects = new TreeMap();
// Build description string (but not for the snippets.xml file)
if (xmlFile instanceof String) {
List authorL = root.getChildren("author");
String author = "<unknown>";
if (root.getAttributeValue("name") != null) {
author = root.getAttributeValue("name");
} else if (authorL.size() > 0) {
author = ((Element) authorL.get(0)).getValue();
}
String description =
"from file "
+ xmlFile.toString()
+ " (author: "
+ author
+ ") on "
+ new Date().toString();
HasIdentifiers.addGlobalIdentifier("_description_", description);
}
// Get all macro definitions, and remove them from document
TreeMap macroMap = ParseUtils.getMacroDefs(root);
// Process all macro expansions; replace macro expansion request with result
ParseUtils.expandMacros(root, macroMap);
// Get all elements in document, and assign identifiers to them;
idMap = ParseUtils.parseId(root, prevIdMap);
// Rewriting done; output debug XML code
if (root.getAttributeValue("debug") != null) {
XMLOutputter outputter = new XMLOutputter();
FileOutputStream fos = new FileOutputStream(xmlFile + ".debug");
outputter.output(document, fos);
fos.close();
}
} catch (JDOMException e) { // indicates a well-formedness or other error
throw new Error("JDOMException: " + e.getMessage());
} catch (IOException e) { // indicates an IO problem
throw new Error("IOException: " + e.getMessage());
}
}
public static HMM parseHMM(Element hmmelt, TreeMap idMap, TreeMap objects) {
HMM hmm = new HMM(hmmelt, idMap, objects);
hmm.analyze(objects);
objects.put(hmmelt.getAttributeValue("id"), hmm);
return hmm;
}
private void load_snap_from_xml(Element snap, StructureCollection structs, LinkedList tempList)
throws VisualizerLoadException {
Iterator iterator = snap.getChildren().iterator();
if (!iterator.hasNext()) throw new VisualizerLoadException("Ran out of elements");
structs.loadTitle((Element) (iterator.next()), tempList, this);
structs.calcDimsAndStartPts(tempList, this);
if (!iterator.hasNext()) return;
Element child = (Element) iterator.next();
if (child.getName().compareTo("doc_url") == 0) {
// load the doc_url
add_a_documentation_URL(child.getText().trim());
if (!iterator.hasNext()) return;
child = (Element) iterator.next();
}
if (child.getName().compareTo("pseudocode_url") == 0) {
// load the psuedocode_url
add_a_pseudocode_URL(child.getText().trim());
if (!iterator.hasNext()) return;
child = (Element) iterator.next();
}
if (child.getName().compareTo("audio_text") == 0) {
// load the psuedocode_url
add_audio_text(child.getText().trim());
if (!iterator.hasNext()) return;
child = (Element) iterator.next();
}
// create & load the individual structures, hooking them into the StructureCollection.
// linespernode : calculate it at end of loadStructure call
while (child.getName().compareTo("question_ref") != 0) {
StructureType child_struct = assignStructureType(child);
child_struct.loadStructure(child, tempList, this);
structs.addChild(child_struct);
if (!iterator.hasNext()) return;
child = (Element) iterator.next();
}
if (child.getName().compareTo("question_ref") == 0) {
// set up question ref
add_a_question_xml(child.getAttributeValue("ref"));
} else
// should never happen
throw new VisualizerLoadException(
"Expected question_ref element, but found " + child.getName());
if (iterator.hasNext()) {
child = (Element) iterator.next();
throw new VisualizerLoadException(
"Found " + child.getName() + " when expecting end of snap.");
}
} // load_snap_from_xml
private QueryResult gatherResultInfoForSelectQuery(
String queryString, int queryNr, boolean sorted, Document doc, String[] rows) {
Element root = doc.getRootElement();
// Get head information
Element child =
root.getChild("head", Namespace.getNamespace("http://www.w3.org/2005/sparql-results#"));
// Get result rows (<head>)
List headChildren =
child.getChildren(
"variable", Namespace.getNamespace("http://www.w3.org/2005/sparql-results#"));
Iterator it = headChildren.iterator();
ArrayList<String> headList = new ArrayList<String>();
while (it.hasNext()) {
headList.add(((Element) it.next()).getAttributeValue("name"));
}
List resultChildren =
root.getChild("results", Namespace.getNamespace("http://www.w3.org/2005/sparql-results#"))
.getChildren(
"result", Namespace.getNamespace("http://www.w3.org/2005/sparql-results#"));
int nrResults = resultChildren.size();
QueryResult queryResult = new QueryResult(queryNr, queryString, nrResults, sorted, headList);
it = resultChildren.iterator();
while (it.hasNext()) {
Element resultElement = (Element) it.next();
String result = "";
// get the row values and paste it together to one String
for (int i = 0; i < rows.length; i++) {
List bindings =
resultElement.getChildren(
"binding", Namespace.getNamespace("http://www.w3.org/2005/sparql-results#"));
String rowName = rows[i];
for (int j = 0; j < bindings.size(); j++) {
Element binding = (Element) bindings.get(j);
if (binding.getAttributeValue("name").equals(rowName))
if (result.equals(""))
result +=
rowName + ": " + ((Element) binding.getChildren().get(0)).getTextNormalize();
else
result +=
"\n"
+ rowName
+ ": "
+ ((Element) binding.getChildren().get(0)).getTextNormalize();
}
}
queryResult.addResult(result);
}
return queryResult;
}
public void handleElement(Element e) {
// create morph item
if (e.getName().equals("entry")) {
try {
morphItems.add(new MorphItem(e));
} catch (RuntimeException exc) {
System.err.println("Skipping morph item: " + e.getAttributeValue("word"));
System.err.println(exc.toString());
}
}
// create macro item
else if (e.getName().equals("macro")) {
try {
macroItems.add(new MacroItem(e));
} catch (RuntimeException exc) {
System.err.println("Skipping macro item: " + e.getAttributeValue("name"));
System.err.println(exc.toString());
}
}
}
/**
* Método public static void leerArchivoXML(ListaUsuarios listaDeUsuarios): Este método permite
* leer un archivo XML que contiene los datos de los usuarios a través de jdom
*/
public static void leerArchivoXML(ListaUsuario listaDeUsuarios) {
try {
SAXBuilder builder = new SAXBuilder();
/* Se crea un documento nuevo con el nombre del archivo */
Document doc = builder.build(nombreArchivo);
/* Se obtiene la raíz del archivo (la etiqueta inicial) */
Element raiz = doc.getRootElement();
/* Se puede obtener el atributo de la raíz (de la etiqueta) */
System.out.println(raiz.getAttributeValue("tipo"));
/* Se obtienen todos los hijos cuya etiqueta esa "usuario" */
/* y se asignan esos hijos a un List */
List listaUsuarios = raiz.getChildren("usuario");
System.out.println("Formada por:" + listaUsuarios.size() + " usuarios");
System.out.println("------------------");
/* Se genera un iterador para recorrer el List que se generó */
Iterator i = listaUsuarios.iterator();
/* Se recorre el List */
while (i.hasNext()) {
/* Se obtiene cada uno y se asigna a un objeto de tipo Element */
Element e = (Element) i.next();
/* Se obtiene el nombre, apellido y cargo de cada una de las etiquetas */
/* hijas de usuario, es decir, nombre, apellido y cargo */
Element nick = e.getChild("nick");
Element clave = e.getChild("clave");
Element nombre = e.getChild("nombre");
Element apellido = e.getChild("apellido");
Element fechanac = e.getChild("fechanac");
Element avatar = e.getChild("avatar");
/* Se crea un nodo nuevo con la información y se agrega a la lista de usuarios */
Usuario elUsuario =
new Usuario(
nick.getText(),
clave.getText(),
nombre.getText(),
apellido.getText(),
fechanac.getText(),
avatar.getText());
listaDeUsuarios.AgregarElemento(elUsuario);
}
} catch (Exception e) {
e.printStackTrace();
}
}
public void parseCode() {
// Parse all <code> and <parameter> elements
List codeList = ParseUtils.parseDescendants(root, "code", idMap);
Iterator i = codeList.iterator();
while (i.hasNext()) {
Element codeElt = (Element) i.next();
String codeId = codeElt.getAttributeValue("id");
if (objects.containsKey(codeId)) {
System.out.println("Note: Shadowing definition of <code id=\"" + codeId + "\">");
}
objects.put(codeId, new Code(codeElt, idMap));
}
}
// get licensing features, with appropriate defaults
@SuppressWarnings("unchecked")
private void loadLicensingFeatures(Element licensingElt) {
List<LicensingFeature> licensingFeats = new ArrayList<LicensingFeature>();
boolean containsLexFeat = false;
if (licensingElt != null) {
for (Iterator<Element> it = licensingElt.getChildren("feat").iterator(); it.hasNext(); ) {
Element featElt = it.next();
String attr = featElt.getAttributeValue("attr");
if (attr.equals("lex")) containsLexFeat = true;
String val = featElt.getAttributeValue("val");
List<String> alsoLicensedBy = null;
String alsoVals = featElt.getAttributeValue("also-licensed-by");
if (alsoVals != null) {
alsoLicensedBy = Arrays.asList(alsoVals.split("\\s+"));
}
boolean licenseEmptyCats = true;
boolean licenseMarkedCats = false;
boolean instantiate = true;
byte loc = LicensingFeature.BOTH;
String lmc = featElt.getAttributeValue("license-marked-cats");
if (lmc != null) {
licenseMarkedCats = Boolean.valueOf(lmc).booleanValue();
// change defaults
licenseEmptyCats = false;
loc = LicensingFeature.TARGET_ONLY;
instantiate = false;
}
String lec = featElt.getAttributeValue("license-empty-cats");
if (lec != null) {
licenseEmptyCats = Boolean.valueOf(lec).booleanValue();
}
String inst = featElt.getAttributeValue("instantiate");
if (inst != null) {
instantiate = Boolean.valueOf(inst).booleanValue();
}
String locStr = featElt.getAttributeValue("location");
if (locStr != null) {
if (locStr.equals("target-only")) loc = LicensingFeature.TARGET_ONLY;
if (locStr.equals("args-only")) loc = LicensingFeature.ARGS_ONLY;
if (locStr.equals("both")) loc = LicensingFeature.BOTH;
}
licensingFeats.add(
new LicensingFeature(
attr, val, alsoLicensedBy, licenseEmptyCats, licenseMarkedCats, instantiate, loc));
}
}
if (!containsLexFeat) {
licensingFeats.add(LicensingFeature.defaultLexFeature);
}
_licensingFeatures = new LicensingFeature[licensingFeats.size()];
licensingFeats.toArray(_licensingFeatures);
}
/** Make a keybinding out of an XML element */
public static KeyBinding readXML(Element e) {
try {
String plugin = e.getAttributeValue("plugin");
String desc = e.getAttributeValue("desc");
KeyBinding b = new KeyBinding(plugin, desc, null);
for (Object neo : e.getChildren()) {
Element ne = (Element) neo;
if (ne.getName().equals("char"))
b.types.add(new TypeChar(ne.getAttributeValue("char").charAt(0)));
else if (ne.getName().equals("keycode"))
b.types.add(
new TypeKeycode(
ne.getAttribute("keyCode").getIntValue(),
ne.getAttribute("modifier").getIntValue()));
else if (ne.getName().equals("jinput"))
b.types.add(
new TypeJInput(
ne.getAttributeValue("ident"), ne.getAttribute("value").getFloatValue()));
}
// backwards compatibility
if (e.getAttribute("key") != null) {
TypeChar kb = new TypeChar(e.getAttributeValue("key").charAt(0));
b.types.add(kb);
} else if (e.getAttribute("keyCode") != null) {
TypeKeycode kb =
new TypeKeycode(
e.getAttribute("keyCode").getIntValue(), e.getAttribute("modifier").getIntValue());
b.types.add(kb);
}
return b;
} catch (DataConversionException e1) {
e1.printStackTrace();
return null;
}
}
// get relation sort order, or use defaults
private void loadRelationSortOrder(Element relationSortingElt) {
// use defaults if no order specified
if (relationSortingElt == null) {
for (int i = 0; i < defaultRelationSortOrder.length; i++) {
_relationIndexMap.put(defaultRelationSortOrder[i], new Integer(i));
}
return;
}
// otherwise load from 'order' attribute
String orderAttr = relationSortingElt.getAttributeValue("order");
String[] relSortOrder = orderAttr.split("\\s+");
for (int i = 0; i < relSortOrder.length; i++) {
_relationIndexMap.put(relSortOrder[i], new Integer(i));
}
}
public void handleElement(Element e) {
// create family
if (e.getName().equals("family")) {
try {
lexicon.add(new Family(e));
} catch (RuntimeException exc) {
System.err.println("Skipping family: " + e.getAttributeValue("name"));
System.err.println(exc.toString());
}
}
// save distributive attributes
else if (e.getName().equals("distributive-features")) distrElt = e;
// save licensing features
else if (e.getName().equals("licensing-features")) licensingElt = e;
// save relation sort order
else if (e.getName().equals("relation-sorting")) relationSortingElt = e;
}
// Empieza La Carga de la Partida
public static void leerArchivoXML(ListaPartida listaDePartidas) {
try {
SAXBuilder builder = new SAXBuilder();
/* Se crea un documento nuevo con el nombre del archivo */
Document doc = builder.build(nombreArchivoPartida);
/* Se obtiene la raíz del archivo (la etiqueta inicial) */
Element raiz = doc.getRootElement();
/* Se puede obtener el atributo de la raíz (de la etiqueta) */
System.out.println(raiz.getAttributeValue("tipo"));
/* Se obtienen todos los hijos cuya etiqueta esa "usuario" */
/* y se asignan esos hijos a un List */
List listaPartida = raiz.getChildren("partida");
System.out.println("Formada por:" + listaPartida.size() + " Partidas");
System.out.println("------------------");
/* Se genera un iterador para recorrer el List que se generó */
Iterator i = listaPartida.iterator();
/* Se recorre el List */
while (i.hasNext()) {
/* Se obtiene cada uno y se asigna a un objeto de tipo Element */
Element e = (Element) i.next();
/* Se obtiene el nombre, apellido y cargo de cada una de las etiquetas */
/* hijas de usuario, es decir, nombre, apellido y cargo */
Element nick = e.getChild("Usuario");
Element ID = e.getChild("ID");
Element fechaactual = e.getChild("fechaacual");
Element fechainicio = e.getChild("fechainicio");
/* Se crea un nodo nuevo con la información y se agrega a la lista de usuarios */
Partida laPartida =
new Partida(
nick.getText(), ID.getContentSize(), fechaactual.getText(), fechainicio.getText());
listaDePartidas.AgregarElemento(laPartida);
}
} catch (Exception e) {
e.printStackTrace();
}
}
private StructureType assignStructureType(Element structure) throws VisualizerLoadException {
String name = structure.getName().toLowerCase();
if (name.compareTo("graph") == 0) {
if (structure.getAttributeValue("weighted").compareTo("true") == 0)
return new Graph_Network("NETWORK");
else return new Graph_Network("GRAPH");
} else if (name.equals("array")) return new MD_Array();
else if (name.equals("no3darray")) return new No3darray();
else if (name.equals("linkedlist")) return new VisLinkedList();
else if (name.equals("no3dlinkedlist")) return new No3dLinkedList();
else if (name.equals("linkedlistnonull")) return new VisLinkedListNoNull();
else if (name.equals("bargraph")) return new BarScat("BAR");
else if (name.equals("scattergraph"))
return new BarScat(
"SCAT"); // not implemented in xml dtd, and does not have a load-from-xml method defined
else if (name.equals("stack")) return new Stack();
else if (name.equals("queue")) return new Queue();
else if (name.equals("tree")) {
if (structure.getChild("binary_node") != null) return new BinaryTree();
else return new GeneralTree();
} else if (name.equals("text")) return new TextStructure();
// if the XML element name is different from your structure's name, you can do something like
// this:
// else if( name.equalsIgnoreCase("node"))
// return new Node();
else if (name.equals("legend")) return new LegendofColors();
else {
// try dynamic typing
try {
return assignStructureType(name);
} catch (Exception e) {
throw new VisualizerLoadException(
"Unable to instantiate class \"" + name + "\":\n" + e.getMessage());
}
}
}
public static String getSimpleBarChart(Map dataSource, String objectName, HttpSession session)
throws Throwable {
Element chartObject =
XMLHandler.getElementByAttribute(getChartObjectList(), "name", objectName);
List invokeFields = chartObject.getChild("InvokeFields").getChildren("Field");
double[][] data = new double[invokeFields.size()][dataSource.size()];
String[] rowKeys = new String[invokeFields.size()];
String[] columnKeys = new String[dataSource.size()];
String columnLabel = chartObject.getChildText("ColumnLabel");
for (int i = 0; i < dataSource.size(); i++) {
Map rec = (Map) dataSource.get("ROW" + i);
columnKeys[i] = DataFilter.show(rec, columnLabel);
for (int j = 0; j < invokeFields.size(); j++) {
data[j][i] =
Double.parseDouble(
rec.get(((Element) invokeFields.get(j)).getAttributeValue("name")).toString());
}
}
for (int i = 0; i < invokeFields.size(); i++) {
rowKeys[i] = ((Element) invokeFields.get(i)).getAttributeValue("label");
}
CategoryDataset dataset = DatasetUtilities.createCategoryDataset(rowKeys, columnKeys, data);
PlotOrientation plotOrientation =
chartObject.getAttributeValue("plotOrientation").equalsIgnoreCase("VERTICAL")
? PlotOrientation.VERTICAL
: PlotOrientation.HORIZONTAL;
JFreeChart chart =
ChartFactory.createBarChart3D(
chartObject.getAttributeValue("title"),
chartObject.getAttributeValue("categoryAxisLabel"),
chartObject.getAttributeValue("valueAxisLabel"),
dataset,
plotOrientation,
chartObject.getAttribute("showLegend").getBooleanValue(),
chartObject.getAttribute("showToolTips").getBooleanValue(),
chartObject.getAttribute("urls").getBooleanValue());
CategoryPlot C3dplot = (CategoryPlot) chart.getPlot();
if (chartObject.getAttribute("alpha") != null) {
C3dplot.setForegroundAlpha(chartObject.getAttribute("alpha").getFloatValue());
}
BarRenderer3D barrenderer = (BarRenderer3D) C3dplot.getRenderer();
barrenderer.setLabelGenerator(new StandardCategoryLabelGenerator());
barrenderer.setItemLabelsVisible(true);
barrenderer.setPositiveItemLabelPosition(
new ItemLabelPosition(ItemLabelAnchor.OUTSIDE1, TextAnchor.BASELINE_CENTER));
int width, height;
if (chartObject.getAttributeValue("width").equalsIgnoreCase("auto")) {
width = (50 * dataSource.size()) * invokeFields.size() + 100;
} else {
width = Integer.parseInt(chartObject.getAttributeValue("width"));
}
if (chartObject.getAttributeValue("height").equalsIgnoreCase("auto")) {
height = (50 * dataSource.size()) * invokeFields.size() + 100;
} else {
height = Integer.parseInt(chartObject.getAttributeValue("height"));
}
return ServletUtilities.saveChartAsPNG(chart, width, height, session);
}
public static String getBarSeries(Map dataSource, String objectName, HttpSession session)
throws Exception {
DefaultKeyedValues barValues = new DefaultKeyedValues();
DefaultKeyedValues seriesValues = new DefaultKeyedValues();
Element chartObject =
XMLHandler.getElementByAttribute(getChartObjectList(), "name", objectName);
Element barField = chartObject.getChild("BarFields").getChild("Field");
Element seriesField = chartObject.getChild("SeriesFields").getChild("Field");
for (int i = 0; i < dataSource.size(); i++) {
Map rec = (Map) dataSource.get("ROW" + i);
barValues.addValue(
DataFilter.show(rec, chartObject.getChildText("ColumnLabel")),
Double.parseDouble(rec.get(barField.getAttributeValue("name")).toString()));
seriesValues.addValue(
DataFilter.show(rec, chartObject.getChildText("ColumnLabel")),
Double.parseDouble(rec.get(seriesField.getAttributeValue("name")).toString()));
}
CategoryDataset dataset =
DatasetUtilities.createCategoryDataset(barField.getAttributeValue("label"), barValues);
PlotOrientation plotOrientation =
chartObject.getAttributeValue("plotOrientation").equalsIgnoreCase("VERTICAL")
? PlotOrientation.VERTICAL
: PlotOrientation.HORIZONTAL;
JFreeChart chart =
ChartFactory.createBarChart3D(
chartObject.getAttributeValue("title"),
chartObject.getAttributeValue("categoryAxisLabel"),
chartObject.getAttributeValue("valueAxisLabel"),
dataset,
plotOrientation,
chartObject.getAttribute("showLegend").getBooleanValue(),
chartObject.getAttribute("showToolTips").getBooleanValue(),
chartObject.getAttribute("urls").getBooleanValue());
CategoryPlot categoryplot = chart.getCategoryPlot();
LineRenderer3D lineRenderer = new LineRenderer3D();
CategoryDataset datasetSeries =
DatasetUtilities.createCategoryDataset(
seriesField.getAttributeValue("label"), seriesValues);
categoryplot.setDataset(1, datasetSeries);
categoryplot.setRangeAxis(1, new NumberAxis3D(seriesField.getAttributeValue("label")));
categoryplot.setRenderer(1, lineRenderer);
categoryplot.mapDatasetToRangeAxis(1, 1);
BarRenderer3D barrenderer = (BarRenderer3D) categoryplot.getRenderer();
barrenderer.setLabelGenerator(new StandardCategoryLabelGenerator());
barrenderer.setItemLabelsVisible(true);
barrenderer.setPositiveItemLabelPosition(
new ItemLabelPosition(ItemLabelAnchor.OUTSIDE1, TextAnchor.BASELINE_CENTER));
// lineRenderer.setLabelGenerator(new StandardCategoryLabelGenerator());
// lineRenderer.setItemLabelsVisible(true);
// lineRenderer.setPositiveItemLabelPosition(
// new ItemLabelPosition(ItemLabelAnchor.OUTSIDE10, TextAnchor.CENTER));
float alpha = 0.7F;
if (chartObject.getAttribute("alpha") != null) {
alpha = chartObject.getAttribute("alpha").getFloatValue();
}
categoryplot.setForegroundAlpha(alpha);
int width, height;
if (chartObject.getAttributeValue("width").equalsIgnoreCase("auto")) {
width = (50 * dataSource.size()) + 100;
} else {
width = Integer.parseInt(chartObject.getAttributeValue("width"));
}
if (chartObject.getAttributeValue("height").equalsIgnoreCase("auto")) {
height = (50 * dataSource.size()) + 100;
} else {
height = Integer.parseInt(chartObject.getAttributeValue("height"));
}
return ServletUtilities.saveChartAsPNG(chart, width, height, session);
}
public static String getSimplePieChart(Map dataSource, String objectName, HttpSession session)
throws Throwable {
DefaultPieDataset dataset = new DefaultPieDataset();
Element chartObject =
XMLHandler.getElementByAttribute(getChartObjectList(), "name", objectName);
String title = chartObject.getAttributeValue("title");
int width = Integer.parseInt(chartObject.getAttributeValue("width"));
int height = Integer.parseInt(chartObject.getAttributeValue("height"));
Element LabelKeys = chartObject.getChild("Labels");
Element ValueKeys = chartObject.getChild("Values");
String valueKey = ValueKeys.getText();
String valueType = ValueKeys.getAttributeValue("type");
List labelKeys = LabelKeys.getChildren("Label");
String labelKey = LabelKeys.getText();
if (valueType.equalsIgnoreCase("number")) {
for (int i = 0; i < dataSource.size(); i++) {
Map rec = (Map) dataSource.get("ROW" + i);
Number value = (Number) rec.get(valueKey);
String label;
if (labelKeys.isEmpty()) {
label = DataFilter.show(rec, labelKey);
} else {
label = ((Element) labelKeys.get(i)).getText();
}
dataset.setValue(label, value);
}
} else {
for (int i = 0; i < dataSource.size(); i++) {
Map rec = (Map) dataSource.get("ROW" + i);
double value = (Double) rec.get(valueKey);
String label;
if (labelKeys.isEmpty()) {
label = DataFilter.show(rec, labelKey);
} else {
label = ((Element) labelKeys.get(i)).getText();
}
dataset.setValue(label, value);
}
}
JFreeChart chart =
ChartFactory.createPieChart3D(
title,
dataset,
chartObject.getAttribute("showLegend").getBooleanValue(),
chartObject.getAttribute("showToolTips").getBooleanValue(),
chartObject.getAttribute("urls").getBooleanValue());
PiePlot3D pie3dplot = (PiePlot3D) chart.getPlot();
float alpha = 0.7F;
if (chartObject.getAttribute("alpha") != null) {
alpha = chartObject.getAttribute("alpha").getFloatValue();
}
pie3dplot.setForegroundAlpha(alpha);
return ServletUtilities.saveChartAsPNG(chart, width, height, null, session);
}
// public List getUserStoryList(String sessionId,String iterationId,ServletOutputStream out) {
public List getUserStoryList(String sessionId, String iterationId, PrintWriter out) {
List<Map> list = new ArrayList<Map>();
statusMap.put(sessionId, "0");
try {
String apiURL =
rallyApiHost
+ "/hierarchicalrequirement?"
+ "query=(Iteration%20=%20"
+ rallyApiHost
+ "/iteration/"
+ iterationId
+ ")&fetch=true&start=1&pagesize=100";
log.info("getUserStoryList apiURL=" + apiURL);
String responseXML = getRallyXML(apiURL);
org.jdom.input.SAXBuilder bSAX = new org.jdom.input.SAXBuilder();
org.jdom.Document doc = bSAX.build(new StringReader(responseXML));
Element root = doc.getRootElement();
XPath xpath = XPath.newInstance("//Object");
List xlist = xpath.selectNodes(root);
int totalSteps = xlist.size() + 1;
int currentStep = 0;
List taskRefLink = new ArrayList();
Iterator iter = xlist.iterator();
while (iter.hasNext()) {
double totalTimeSpent = 0.0D;
Map map = new HashMap();
Element item = (Element) iter.next();
String objId = item.getChildText("ObjectID");
String name = item.getChildText("Name");
String planEstimate = item.getChildText("PlanEstimate");
String formattedId = item.getChildText("FormattedID");
String taskActualTotal = item.getChildText("TaskActualTotal");
String taskEstimateTotal = item.getChildText("TaskEstimateTotal");
String taskRemainingTotal = item.getChildText("TaskRemainingTotal");
String scheduleState = item.getChildText("ScheduleState");
Element ownerElement = item.getChild("Owner");
String owner = "";
String ownerRef = "";
if (ownerElement != null) {
owner = ownerElement.getAttributeValue("refObjectName");
}
Element taskElements = item.getChild("Tasks");
// List taskElementList=taskElements.getContent();
List taskElementList = taskElements.getChildren();
List taskList = new ArrayList();
log.info("taskElements.getChildren=" + taskElements);
log.info("taskList=" + taskElementList);
for (int i = 0; i < taskElementList.size(); i++) {
Element taskElement = (Element) taskElementList.get(i);
String taskRef = taskElement.getAttributeValue("ref");
String[] objectIdArr = taskRef.split("/");
String objectId = objectIdArr[objectIdArr.length - 1];
log.info("objectId=" + objectId);
// Map taskMap=getTaskMap(taskRef);
Map taskMap = getTaskMapBatch(objectId);
double taskTimeSpentTotal =
Double.parseDouble((String) taskMap.get("taskTimeSpentTotal"));
totalTimeSpent += taskTimeSpentTotal;
taskList.add(taskMap);
}
map.put("type", "userstory");
map.put("formattedId", formattedId);
map.put("name", name);
map.put("taskStatus", scheduleState);
map.put("owner", owner);
map.put("planEstimate", planEstimate);
map.put("taskEstimateTotal", taskEstimateTotal);
map.put("taskRemainingTotal", taskRemainingTotal);
map.put("taskTimeSpentTotal", "" + totalTimeSpent);
list.add(map);
list.addAll(taskList);
++currentStep;
double percentage = 100.0D * currentStep / totalSteps;
String status = "" + Math.round(percentage);
statusMap.put(sessionId, status);
out.println("<script>parent.updateProcessStatus('" + status + "%')</script>" + status);
out.flush();
log.info("out.flush..." + status);
// log.info("status="+status+" sessionId="+sessionId);
// log.info("L1 statusMap="+statusMap+" "+statusMap.hashCode());
}
double planEstimate = 0.0D;
double taskEstimateTotal = 0.0D;
double taskRemainingTotal = 0.0D;
double taskTimeSpentTotal = 0.0D;
Map iterationMap = new HashMap();
for (Map map : list) {
String type = (String) map.get("type");
String planEstimateStr = (String) map.get("planEstimate");
log.info("planEstimateStr=" + planEstimateStr);
if ("userstory".equals(type)) {
if (planEstimateStr != null) {
planEstimate += Double.parseDouble(planEstimateStr);
}
taskEstimateTotal += Double.parseDouble((String) map.get("taskEstimateTotal"));
taskRemainingTotal += Double.parseDouble((String) map.get("taskRemainingTotal"));
taskTimeSpentTotal += Double.parseDouble((String) map.get("taskTimeSpentTotal"));
}
}
apiURL = rallyApiHost + "/iteration/" + iterationId + "?fetch=true";
log.info("iteration apiURL=" + apiURL);
responseXML = getRallyXML(apiURL);
bSAX = new org.jdom.input.SAXBuilder();
doc = bSAX.build(new StringReader(responseXML));
root = doc.getRootElement();
xpath = XPath.newInstance("//Iteration");
xlist = xpath.selectNodes(root);
String projName = "";
String iterName = "";
String iterState = "";
iter = xlist.iterator();
while (iter.hasNext()) {
Element item = (Element) iter.next();
iterName = item.getChildText("Name");
iterState = item.getChildText("State");
Element projElement = item.getChild("Project");
projName = projElement.getAttributeValue("refObjectName");
}
iterationMap.put("type", "iteration");
iterationMap.put("formattedId", "");
iterationMap.put("name", projName + " - " + iterName);
iterationMap.put("taskStatus", iterState);
iterationMap.put("owner", "");
iterationMap.put("planEstimate", "" + planEstimate);
iterationMap.put("taskEstimateTotal", "" + taskEstimateTotal);
iterationMap.put("taskRemainingTotal", "" + taskRemainingTotal);
iterationMap.put("taskTimeSpentTotal", "" + taskTimeSpentTotal);
list.add(0, iterationMap);
statusMap.put(sessionId, "100");
log.info("L2 statusMap=" + statusMap);
log.info("L2 verify=" + getProcessStatus(sessionId));
log.info("-----------");
// String jsonData=JsonUtil.encodeObj(list);
String jsonData = JSONValue.toJSONString(list);
out.println("<script>parent.tableResult=" + jsonData + "</script>");
out.println("<script>parent.showTableResult()</script>");
} catch (Exception ex) {
log.error("ERROR: ", ex);
}
return list;
}
public List getIterationList(String projectId) {
List<Map> list = new ArrayList<Map>();
try {
String apiUrl =
rallyApiHost
+ "/iteration?"
+ "project="
+ rallyApiHost
+ "/project/"
+ projectId
+ "&fetch=true&order=Name%20desc&start=1&pagesize=100";
String checkProjectRef = rallyApiHost + "/project/" + projectId;
log.info("rallyApiUrl:" + apiUrl);
log.info("checkProjectRef:" + checkProjectRef);
String responseXML = getRallyXML(apiUrl);
SimpleDateFormat ISO8601FORMAT = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
Date currentDate = new Date();
org.jdom.input.SAXBuilder bSAX = new org.jdom.input.SAXBuilder();
org.jdom.Document doc = bSAX.build(new StringReader(responseXML));
Element root = doc.getRootElement();
XPath xpath = XPath.newInstance("//Object");
List xlist = xpath.selectNodes(root);
Iterator iter = xlist.iterator();
while (iter.hasNext()) {
Map map = new HashMap();
Element item = (Element) iter.next();
String objId = item.getChildText("ObjectID");
String name = item.getChildText("Name");
String state = item.getChildText("State");
String startDateStr = item.getChildText("StartDate");
String endDateStr = item.getChildText("EndDate");
Date startDate = ISO8601FORMAT.parse(startDateStr);
Date endDate = ISO8601FORMAT.parse(endDateStr);
boolean isCurrent = false;
int startCheck = startDate.compareTo(currentDate);
int endCheck = endDate.compareTo(currentDate);
if (startCheck < 0 && endCheck > 0) {
isCurrent = true;
}
log.info("name=" + name + " isCurrent=" + isCurrent);
String releaseRef = item.getAttribute("ref").getValue();
// In child project, parent object have to be filiered
Element projectElement = item.getChild("Project");
String projectRef = projectElement.getAttributeValue("ref");
if (projectRef.equals(checkProjectRef)) {
map.put("objId", objId);
map.put("rallyRef", releaseRef);
map.put("name", name);
map.put("state", state);
map.put("isCurrent", "" + isCurrent);
list.add(map);
}
}
log.info("-----------");
} catch (Exception ex) {
log.error("ERROR: ", ex);
}
return list;
}
public List getUserTimeSpentByDate(String userObjectId, String startDate, String endDate) {
List list = new ArrayList();
log.info("userObjectId=" + userObjectId);
log.info("startDate=" + startDate);
log.info("endDate=" + endDate);
try {
String apiUrl =
rallyApiHost
+ "/timeentryvalue?query=((TimeEntryItem.User.ObjectId%20=%20"
+ userObjectId
+ ")"
+ "%20and%20((DateVal%20%3E=%20"
+ startDate
+ ")%20and%20(DateVal%20%3C=%20"
+ endDate
+ ")))"
+ "&start=1&pagesize=100&fetch=true";
log.info("apiUrl=" + apiUrl);
String responseXML = getRallyXML(apiUrl);
log.info("responseXML=" + responseXML);
org.jdom.input.SAXBuilder bSAX = new org.jdom.input.SAXBuilder();
org.jdom.Document doc = bSAX.build(new StringReader(responseXML));
Element root = doc.getRootElement();
XPath xpath = XPath.newInstance("//Object");
List xlist = xpath.selectNodes(root);
Iterator iter = xlist.iterator();
while (iter.hasNext()) {
// Map map=new HashMap();
Element item = (Element) iter.next();
String hours = item.getChildText("Hours");
Element timeEntryItemElement = item.getChild("TimeEntryItem");
String timeEntryItemRef = timeEntryItemElement.getAttributeValue("ref");
Map map = getUserStoryTaskMap(timeEntryItemRef);
String checkTaskId = (String) map.get("taskFormattedId");
boolean isExist = false;
for (int i = 0; i < list.size(); i++) {
Map existMap = (Map) list.get(i);
log.info("existMap=" + existMap);
String existTaskId = (String) existMap.get("taskFormattedId");
log.info("existTaskId=" + existTaskId);
log.info("checkTaskId=" + checkTaskId);
if (existTaskId != null && existTaskId.equals(checkTaskId)) {
isExist = true;
String existHours = (String) existMap.get("hours");
double eHour = 0.0D;
if (!"".equals(existHours)) {
eHour = Double.parseDouble(existHours);
}
double nHour = 0.0D;
if (!"".equals(hours)) {
nHour = Double.parseDouble(hours);
}
log.info("nHour=" + nHour);
log.info("eHour=" + eHour);
nHour += eHour;
log.info("2 nHour=" + nHour);
existMap.put("hours", "" + nHour);
break;
}
}
if (!isExist) {
map.put("hours", hours);
list.add(map);
}
log.info("hours=" + hours);
log.info("timeEntryItemRef=" + timeEntryItemRef);
// list.add(map);
}
Collections.sort(
list,
new Comparator<Map<String, String>>() {
public int compare(Map<String, String> m1, Map<String, String> m2) {
if (m1.get("projectName") == null || m2.get("projectName") == null) return -1;
return m1.get("projectName").compareTo(m2.get("projectName"));
}
});
// Sum up the total time
double totalTaskEstimate = 0.0D;
double totalTaskRemaining = 0.0D;
double totalHours = 0.0D;
for (int i = 0; i < list.size(); i++) {
Map map = (Map) list.get(i);
log.info("taskEstimate=" + (String) map.get("taskEstimate"));
log.info("taskRemaining=" + (String) map.get("taskRemaining"));
log.info("hours=" + (String) map.get("hours"));
log.info("map==" + map);
try {
double taskEstimate = Double.parseDouble((String) map.get("taskEstimate"));
double taskRemaining = Double.parseDouble((String) map.get("taskRemaining"));
double hours = Double.parseDouble((String) map.get("hours"));
totalTaskEstimate += taskEstimate;
totalTaskRemaining += taskRemaining;
totalHours += hours;
} catch (Exception e) {
log.info("ERROR in parsing number" + e);
}
}
Map firstMap = new HashMap();
firstMap.put("taskFormattedId", "");
firstMap.put("taskName", "");
firstMap.put("taskState", "");
firstMap.put("owner", "");
firstMap.put("taskEstimate", "" + totalTaskEstimate);
firstMap.put("taskRemaining", "" + totalTaskRemaining);
firstMap.put("hours", "" + totalHours);
firstMap.put("projectName", "");
firstMap.put("iterationName", "");
list.add(0, firstMap);
} catch (Exception ex) {
log.error("", ex);
}
return list;
}