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;
}
/**
* This will invoke the <code>startElement</code> callback in the <code>ContentHandler</code>.
*
* @param element <code>Element</code> used in callbacks.
* @param nsAtts <code>List</code> of namespaces to declare with the element or <code>null</code>.
*/
private void startElement(Element element, Attributes nsAtts) throws JDOMException {
String namespaceURI = element.getNamespaceURI();
String localName = element.getName();
String rawName = element.getQualifiedName();
// Allocate attribute list.
AttributesImpl atts = (nsAtts != null) ? new AttributesImpl(nsAtts) : new AttributesImpl();
List attributes = element.getAttributes();
Iterator i = attributes.iterator();
while (i.hasNext()) {
Attribute a = (Attribute) i.next();
atts.addAttribute(
a.getNamespaceURI(),
a.getName(),
a.getQualifiedName(),
getAttributeTypeName(a.getAttributeType()),
a.getValue());
}
try {
contentHandler.startElement(namespaceURI, localName, rawName, atts);
} catch (SAXException se) {
throw new JDOMException("Exception in startElement", se);
}
}
/**
* Processes the messages from the server
*
* @param message
*/
private synchronized void processServerMessage(String message) {
SAXBuilder builder = new SAXBuilder();
String what = new String();
Document doc = null;
try {
doc = builder.build(new StringReader(message));
Element root = doc.getRootElement();
List childs = root.getChildren();
Iterator i = childs.iterator();
what = ((Element) i.next()).getName();
} catch (Exception e) {
}
if (what.equalsIgnoreCase("LOGIN") == true) _login(doc);
else if (what.equalsIgnoreCase("LOGOUT") == true) _logout(doc);
else if (what.equalsIgnoreCase("MESSAGE") == true) _message(doc);
else if (what.equalsIgnoreCase("WALL") == true) _wall(doc);
else if (what.equalsIgnoreCase("CREATEGROUP") == true) _creategroup(doc);
else if (what.equalsIgnoreCase("JOINGROUP") == true) _joingroup(doc);
else if (what.equalsIgnoreCase("PARTGROUP") == true) _partgroup(doc);
else if (what.equalsIgnoreCase("GROUPMESSAGE") == true) _groupmessage(doc);
else if (what.equalsIgnoreCase("KICK") == true) _kick(doc);
else if (what.equalsIgnoreCase("LISTUSER") == true) _listuser(doc);
else if (what.equalsIgnoreCase("LISTGROUP") == true) _listgroup(doc);
}
protected String getRallyAPIError(String responseXML) {
String errorMsg = "";
try {
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("//Errors");
List xlist = xpath.selectNodes(root);
Iterator iter = xlist.iterator();
while (iter.hasNext()) {
Element item = (Element) iter.next();
errorMsg = item.getChildText("OperationResultError");
}
} catch (Exception e) {
errorMsg = e.toString();
}
return errorMsg;
}
private void deleteJsonJobs(ApplicationInfo appInfo, List<CIJob> selectedJobs)
throws PhrescoException {
try {
if (CollectionUtils.isEmpty(selectedJobs)) {
return;
}
Gson gson = new Gson();
List<CIJob> jobs = getJobs(appInfo);
if (CollectionUtils.isEmpty(jobs)) {
return;
}
// all values
Iterator<CIJob> iterator = jobs.iterator();
// deletable values
for (CIJob selectedInfo : selectedJobs) {
while (iterator.hasNext()) {
CIJob itrCiJob = iterator.next();
if (itrCiJob.getName().equals(selectedInfo.getName())) {
iterator.remove();
break;
}
}
}
writeJsonJobs(appInfo, jobs, CI_CREATE_NEW_JOBS);
} catch (Exception e) {
throw new PhrescoException(e);
}
}
// look up and apply coarts for given rels to each sign in result
private void applyCoarts(List<String> coartRels, Collection<Sign> result) {
List<Sign> inputSigns = new ArrayList<Sign>(result);
result.clear();
List<Sign> outputSigns = new ArrayList<Sign>(inputSigns.size());
// for each rel, lookup coarts and apply to input signs, storing results in output signs
for (Iterator<String> it = coartRels.iterator(); it.hasNext(); ) {
String rel = it.next();
Collection<String> preds = (Collection<String>) _coartRelsToPreds.get(rel);
if (preds == null) continue; // not expected
Collection<Sign> coartResult = getSignsFromRelAndPreds(rel, preds);
if (coartResult == null) continue;
for (Iterator<Sign> it2 = coartResult.iterator(); it2.hasNext(); ) {
Sign coartSign = it2.next();
// apply to each input
for (int j = 0; j < inputSigns.size(); j++) {
Sign sign = inputSigns.get(j);
grammar.rules.applyCoart(sign, coartSign, outputSigns);
}
}
// switch output to input for next iteration
inputSigns.clear();
inputSigns.addAll(outputSigns);
outputSigns.clear();
}
// add results back
result.addAll(inputSigns);
}
/**
* This will take the supplied <code>{@link Element}</code> and transfer its namespaces to the
* global namespace storage.
*
* @param element <code>Element</code> to read namespaces from.
*/
private void transferNamespaces(Element element) {
Iterator i = declaredNamespaces.iterator();
while (i.hasNext()) {
Namespace ns = (Namespace) i.next();
if (ns != element.getNamespace()) {
element.addNamespaceDeclaration(ns);
}
}
declaredNamespaces.clear();
}
public void parseCodeGeneration() {
// parse all <codeGeneration> elements
List codeGenList = ParseUtils.parseDescendants(root, "codeGeneration", idMap);
Iterator i = codeGenList.iterator();
while (i.hasNext()) {
Element cgelt = (Element) i.next();
// It's the side effect that we're after here.
new CodeGeneration(cgelt, idMap, objects);
}
}
/**
* 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 List getUserList() {
List<Map> list = new ArrayList<Map>();
try {
/*
String apiUrl=rallyApiHost+"/user?query="+
"((TeamMemberships%20%3D%20https%3A%2F%2Frally1.rallydev.com%2Fslm%2Fwebservice%2F1.34%2Fproject%2F6169133135)%20or%20"+
"(TeamMemberships%20%3D%20https%3A%2F%2Frally1.rallydev.com%2Fslm%2Fwebservice%2F1.34%2Fproject%2F6083311244))"+
"&fetch=true&order=Name&start=1&pagesize=100";
*/
String apiUrl =
rallyApiHost
+ "/user?query=(Disabled%20=%20false)"
+ "&fetch=true&order=Name&start=1&pagesize=100";
log.info("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);
Iterator iter = xlist.iterator();
while (iter.hasNext()) {
Map map = new HashMap();
Element item = (Element) iter.next();
String userRef = item.getAttribute("ref").getValue();
String userName = item.getAttribute("refObjectName").getValue();
String userObjectId = item.getChildText("ObjectID");
map.put("userRef", userRef);
map.put("userObjectId", userObjectId);
map.put("userName", userName);
list.add(map);
}
} catch (Exception ex) {
log.error("", ex);
}
return list;
}
/**
* For a string of 1 or more surface words, return all of the lexical entries for each word as a
* list of sign hashes. Tokenization is performed using the configured tokenizer.
*
* @param w the words in string format
* @return a list of sign hashes
* @exception LexException thrown if word not found
*/
public List<SignHash> getEntriesFromWords(String s) throws LexException {
List<SignHash> entries = new ArrayList<SignHash>();
List<Word> words = tokenizer.tokenize(s);
for (Iterator<Word> it = words.iterator(); it.hasNext(); ) {
Word w = it.next();
SignHash signs = getSignsFromWord(w);
if (signs.size() == 0) {
throw new LexException("Word not in lexicon: \"" + w + "\"");
}
entries.add(signs);
}
return entries;
}
/**
* Process listuser from server
*
* @param doc
*/
private void _listuser(Document doc) {
StringBuffer userlist = new StringBuffer();
Element root = doc.getRootElement();
Element list = root.getChild("listuser");
List users = list.getChildren("user");
Iterator i = users.iterator();
while (i.hasNext()) {
userlist.append(((Element) i.next()).getText());
userlist.append("\n");
}
sendMessage(SERVER, "Users: \n" + userlist);
}
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));
}
}
/**
* This will invoke the callbacks for the content of an element.
*
* @param content element content as a <code>List</code> of nodes.
* @param namespaces <code>List</code> stack of Namespaces in scope.
*/
private void elementContent(List content, NamespaceStack namespaces) throws JDOMException {
for (Iterator i = content.iterator(); i.hasNext(); ) {
Object obj = i.next();
if (obj instanceof Content) {
this.elementContent((Content) obj, namespaces);
} else {
// Not a valid element child. This could happen with
// application-provided lists which may contain non
// JDOM objects.
handleError(new JDOMException("Invalid element content: " + obj));
}
}
}
/**
* Process listgroup from server
*
* @param doc
*/
private void _listgroup(Document doc) {
StringBuffer grouplist = new StringBuffer();
Element root = doc.getRootElement();
Element list = root.getChild("listgroup");
List groups = list.getChildren("group");
Iterator i = groups.iterator();
while (i.hasNext()) {
Element temp = (Element) i.next();
grouplist.append(temp.getChild("name").getText());
grouplist.append("\t");
grouplist.append(temp.getChild("description").getText());
grouplist.append("\n");
}
sendMessage(SERVER, "Groups: \n" + grouplist);
}
// 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();
}
}
public List getProjectList() {
List<Map> list = new ArrayList<Map>();
try {
String apiUrl = rallyApiHost + "/project?" + "fetch=true&order=Name&start=1&pagesize=200";
log.info("rallyApiUrl:" + 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);
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");
map.put("objId", objId);
map.put("name", name);
map.put("state", state);
list.add(map);
}
} catch (Exception ex) {
log.error("ERROR: ", ex);
}
return list;
}
/**
* This will invoke the <code>ContentHandler.startPrefixMapping</code> callback when a new
* namespace is encountered in the <code>Document</code>.
*
* @param element <code>Element</code> used in callbacks.
* @param namespaces <code>List</code> stack of Namespaces in scope.
* @return <code>Attributes</code> declaring the namespaces local to <code>element</code> or
* <code>null</code>.
*/
private Attributes startPrefixMapping(Element element, NamespaceStack namespaces)
throws JDOMException {
AttributesImpl nsAtts = null; // The namespaces as xmlns attributes
Namespace ns = element.getNamespace();
if (ns != Namespace.XML_NAMESPACE) {
String prefix = ns.getPrefix();
String uri = namespaces.getURI(prefix);
if (!ns.getURI().equals(uri)) {
namespaces.push(ns);
nsAtts = this.addNsAttribute(nsAtts, ns);
try {
contentHandler.startPrefixMapping(prefix, ns.getURI());
} catch (SAXException se) {
throw new JDOMException("Exception in startPrefixMapping", se);
}
}
}
// Fire additional namespace declarations
List additionalNamespaces = element.getAdditionalNamespaces();
if (additionalNamespaces != null) {
Iterator itr = additionalNamespaces.iterator();
while (itr.hasNext()) {
ns = (Namespace) itr.next();
String prefix = ns.getPrefix();
String uri = namespaces.getURI(prefix);
if (!ns.getURI().equals(uri)) {
namespaces.push(ns);
nsAtts = this.addNsAttribute(nsAtts, ns);
try {
contentHandler.startPrefixMapping(prefix, ns.getURI());
} catch (SAXException se) {
throw new JDOMException("Exception in startPrefixMapping", se);
}
}
}
}
return nsAtts;
}
// 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;
}
/** Loads the lexicon and morph files. */
public void init(URL lexiconUrl, URL morphUrl) throws IOException {
List<Family> lexicon = null;
List<MorphItem> morph = null;
List<MacroItem> macroModel = null;
// load category families (lexicon), morph forms and macros
lexicon = getLexicon(lexiconUrl);
Pair<List<MorphItem>, List<MacroItem>> morphInfo = getMorph(morphUrl);
morph = morphInfo.a;
macroModel = morphInfo.b;
// index words; also index stems to words, as default preds
// store indexed coarticulation attrs too
_words = new GroupMap<Word, MorphItem>();
_predToWords = new GroupMap<String, Word>();
_coartAttrs = new HashSet<String>();
_indexedCoartAttrs = new HashSet<String>();
for (MorphItem morphItem : morph) {
Word surfaceWord = morphItem.getSurfaceWord();
_words.put(surfaceWord, morphItem);
_predToWords.put(morphItem.getWord().getStem(), surfaceWord);
if (morphItem.isCoart()) {
Word indexingWord = morphItem.getCoartIndexingWord();
_words.put(indexingWord, morphItem);
Pair<String, String> first = indexingWord.getSurfaceAttrValPairs().next();
_indexedCoartAttrs.add(first.a);
for (Iterator<Pair<String, String>> it = surfaceWord.getSurfaceAttrValPairs();
it.hasNext(); ) {
Pair<String, String> p = it.next();
_coartAttrs.add(p.a);
}
}
}
// index entries based on stem+pos
_stems = new GroupMap<String, Object>();
_posToEntries = new GroupMap<String, EntriesItem[]>();
// index entries by supertag+pos, for supertagging
_stagToEntries = new GroupMap<String, EntriesItem>();
// also index rels and coart rels to preds
_relsToPreds = new GroupMap<String, String>();
_coartRelsToPreds = new GroupMap<String, String>();
// and gather list of attributes used per atomic category type
_catsToAttrs = new GroupMap<String, String>();
_lfAttrs = new HashSet<String>();
// and remember family and ent, names, for checking excluded list on morph items
HashSet<String> familyAndEntryNames = new HashSet<String>();
// index each family
for (Family family : lexicon) {
familyAndEntryNames.add(family.getName());
EntriesItem[] entries = family.getEntries();
DataItem[] data = family.getData();
// for generic use when we get an unknown stem
// from the morphological analyzer
if (!family.isClosed()) {
_posToEntries.put(family.getPOS(), entries);
}
// scan through entries
for (int j = 0; j < entries.length; j++) {
// index
EntriesItem eItem = entries[j];
_stagToEntries.put(eItem.getSupertag() + family.getPOS(), eItem);
if (eItem.getStem().length() > 0) {
_stems.put(eItem.getStem() + family.getPOS(), eItem);
}
try {
// gather features
eItem.getCat().forall(gatherAttrs);
// record names
familyAndEntryNames.add(eItem.getName());
familyAndEntryNames.add(eItem.getQualifiedName());
} catch (RuntimeException exc) {
System.err.println("exception for: " + family.getName() + ": " + exc);
}
}
// scan through data
for (int j = 0; j < data.length; j++) {
DataItem dItem = data[j];
_stems.put(
dItem.getStem() + family.getPOS(), new Pair<DataItem, EntriesItem[]>(dItem, entries));
// index non-default preds to words
if (!dItem.getStem().equals(dItem.getPred())) {
Collection<Word> words = (Collection<Word>) _predToWords.get(dItem.getStem());
if (words == null) {
if (!openlex) {
System.out.print("Warning: couldn't find words for pred '");
System.out.println(dItem.getPred() + "' with stem '" + dItem.getStem() + "'");
}
} else {
for (Iterator<Word> it = words.iterator(); it.hasNext(); ) {
_predToWords.put(dItem.getPred(), it.next());
}
}
}
}
// index rels to preds
// nb: this covers relational (eg @x<GenRel>e) and featural (eg @e<tense>past)
// elementary predications
List<String> indexRels = new ArrayList<String>(3);
String familyIndexRel = family.getIndexRel();
if (familyIndexRel.length() > 0) {
indexRels.add(familyIndexRel);
}
for (int j = 0; j < entries.length; j++) {
EntriesItem eItem = entries[j];
String indexRel = eItem.getIndexRel();
if (indexRel.length() > 0 && !indexRel.equals(familyIndexRel)) {
indexRels.add(indexRel);
}
}
for (Iterator<String> it = indexRels.iterator(); it.hasNext(); ) {
String indexRel = it.next();
// nb: not indexing on entries items, b/c some stems are still defaults
for (int j = 0; j < data.length; j++) {
DataItem dItem = data[j];
_relsToPreds.put(indexRel, dItem.getPred());
}
}
// index coart rels (features, really) to preds
String coartRel = family.getCoartRel();
if (coartRel.length() > 0) {
for (int j = 0; j < data.length; j++) {
_coartRelsToPreds.put(coartRel, data[j].getPred());
}
}
}
// index the macros
_macros = new GroupMap<String, FeatureStructure>();
// nb: could just index MacroItem objects for feature structures too;
// this might be a bit cleaner, but life is short
_macroItems = new HashMap<String, MacroItem>();
for (MacroItem mi : macroModel) {
String macName = mi.getName();
FeatureStructure[] specs = mi.getFeatureStructures();
for (int j = 0; j < specs.length; j++) {
_macros.put(macName, specs[j]);
}
// this is for handling LF part of macros
_macroItems.put(macName, mi);
}
// with morph items, check POS, macro names, excluded list for xref
for (MorphItem morphItem : morph) {
Word w = morphItem.getWord();
if (!openlex
&& !_stems.containsKey(w.getStem() + w.getPOS())
&& !_posToEntries.containsKey(w.getPOS())) {
System.err.println(
"Warning: no entries for stem '"
+ w.getStem()
+ "' and POS '"
+ w.getPOS()
+ "' found for word '"
+ w
+ "'");
}
String[] macroNames = morphItem.getMacros();
for (int j = 0; j < macroNames.length; j++) {
if (!_macroItems.containsKey(macroNames[j])) {
System.err.println(
"Warning: macro "
+ macroNames[j]
+ " not found for word '"
+ morphItem.getWord()
+ "'");
}
}
String[] excludedNames = morphItem.getExcluded();
for (int j = 0; j < excludedNames.length; j++) {
if (!familyAndEntryNames.contains(excludedNames[j])) {
System.err.println(
"Warning: excluded family or entry '"
+ excludedNames[j]
+ "' not found for word '"
+ morphItem.getWord()
+ "'");
}
}
}
}