KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > calipso > reportgenerator > reportmanager > StaticReportXmlWriter


1 package com.calipso.reportgenerator.reportmanager;
2
3 import com.calipso.reportgenerator.common.InfoException;
4
5 import java.io.StringWriter JavaDoc;
6 import java.io.IOException JavaDoc;
7 import java.util.Map JavaDoc;
8 import java.util.Iterator JavaDoc;
9
10 import org.w3c.dom.Element JavaDoc;
11 import org.w3c.dom.Document JavaDoc;
12 import org.w3c.dom.Node JavaDoc;
13 import org.apache.xerces.dom.DocumentImpl;
14 import org.apache.xml.serialize.OutputFormat;
15 import org.apache.xml.serialize.XMLSerializer;
16 import com.calipso.reportgenerator.reportcalculator.DataTreeNode;
17 //import com.calipso.reportgenerator.reportcalculator.CubeFloat;
18 import com.calipso.reportgenerator.reportcalculator.DataTreeSubItem;
19 import com.calipso.reportgenerator.reportcalculator.SharedFloat;
20 import com.calipso.reportgenerator.common.*;
21
22 /**
23  * Esta clase se encarga de generar el XML de salida
24  * para un reporte de tipo estatico. Result.xml
25  */
26
27 public class StaticReportXmlWriter implements ReportXmlWriter {
28   private ReportData reportData;
29   private ReportSpec reportSpec;
30   private Map JavaDoc paramValues;
31   private Document JavaDoc document;
32
33   /**
34    * Inicializa una instancia de <code>StaticReportXmlWriter</code>
35    * @param reportData
36    * @param reportSpec
37    * @param paramValues
38    */
39   public StaticReportXmlWriter(ReportData reportData, ReportSpec reportSpec, Map JavaDoc paramValues) {
40     this.reportData = reportData;
41     this.reportSpec = reportSpec;
42     this.paramValues = paramValues;
43   }
44
45   /**
46    * Devuelve la instancia de <code>ReportData</code> asociado a la
47    * instancia de <code>StaticReportXmlWriter</code>
48    * @return
49    */
50   public ReportData getReportData() {
51     return reportData;
52   }
53
54   /**
55    * Devuelve la instancia de <code>StaticReportData</code> asociado a la
56    * instancia de <code>StaticReportXmlWriter</code>
57    * @return
58    */
59   public StaticReportData getStaticReportData() {
60     return (StaticReportData) getReportData();
61   }
62
63   /**
64    * Devuelve la instancia de <code>ReportSpec</code> asociado a la
65    * instancia de <code>StaticReportXmlWriter</code>
66    * @return
67    */
68   public ReportSpec getReportSpec() {
69     return reportSpec;
70   }
71
72   /**
73    * Devuelve un conjunto de datos que representa
74    * los valores de los parametros
75    * @return
76    */
77   public Map JavaDoc getParamValues() {
78     return paramValues;
79   }
80
81   /**
82    * Crea un nuevo documento para comenzar la escritura a XML.
83    */
84   private void startDocument() {
85     document = new DocumentImpl();
86   }
87
88   /*private Element createRoot() {
89     Element root;
90     root = createElement("Result");
91     document.appendChild(root);
92     String reportDefName = getReportSpec().getDescription();
93     root.setAttribute("ReportRefinition", reportDefName);
94     return root;
95   } */
96
97   /**
98    * Genera el arbol que representa el XML de salida.
99    * @return
100    * @throws InfoException
101    */
102   public StringWriter JavaDoc getXml() throws InfoException {
103     try {
104       //Element repElem, root;
105 startDocument();
106       //root = createRoot();
107 DataTreeNode dataTreeNode = getStaticReportData().getDataTree().getRoot();
108       dataTreeNode.setValue(getReportSpec().getDescription());
109       generateNode(dataTreeNode, document);
110       return getStream();
111     } catch (Exception JavaDoc e) {
112       throw new InfoException(LanguageTraslator.traslate("99"));
113     }
114   }
115
116   /**
117    * Genera un nodo XML a partir de un <code>DataTreeNode</code>.
118    * @param dataTreeNode
119    * @param parent
120    */
121   private void generateNode(DataTreeNode dataTreeNode, Node JavaDoc parent) {
122     Node JavaDoc element = createNodeElement(getTagName(dataTreeNode.getDimensionIndex()), dataTreeNode.getValue());
123     parent.appendChild(element);
124     fillMetrics(dataTreeNode, element);
125     fillSubItems(dataTreeNode, element);
126     fillSubNodes(dataTreeNode, element);
127   }
128
129   /**
130    * Obtiene la descripcion a mostrar para un nodo del XML a partir
131    * de un indice.
132    * @param dimensionIndex
133    * @return
134    */
135   private String JavaDoc getTagName(int dimensionIndex) {
136     if (dimensionIndex >= 0) {
137       return ((ReportDimensionSpec) reportSpec.getDimensionsByIndex().get(dimensionIndex)).getName();
138     }
139     else {
140       return "Report";
141     }
142   }
143
144   /**
145    * Genera nodos hijos en base a un nodo padre siempre que el diccionario
146    * de hijos que tiene el padre tenga informacion.
147    * @param dataTreeNode
148    * @param parent
149    */
150   private void fillSubNodes(DataTreeNode dataTreeNode, Node JavaDoc parent) {
151     Iterator JavaDoc iterator = dataTreeNode.getSubNodes().values().iterator();
152     while (iterator.hasNext()) {
153       DataTreeNode current = (DataTreeNode) iterator.next();
154       generateNode(current, parent);
155     }
156   }
157
158   /**
159    * Genera los nodos para un nodo del XML siempre y cuando
160    * la lista subItems del nodo contenga informacion.
161    * @param dataTreeNode
162    * @param element
163    */
164   private void fillSubItems(DataTreeNode dataTreeNode, Node JavaDoc element) {
165     int[] dims = getStaticReportData().getDataTree().getQuery().getNoGroupDimensions();
166     int[] mets = getStaticReportData().getDataTree().getQuery().getMetrics();
167     int[] accmets = getStaticReportData().getDataTree().getQuery().getAccumulableMetrics();
168
169     for (int i = 0; i < dataTreeNode.getSubItems().size(); i++) {
170       DataTreeSubItem subItem = (DataTreeSubItem) dataTreeNode.getSubItems().get(i);
171       Element JavaDoc item = createNodeElement("Item", String.valueOf(i));
172       element.appendChild(item);
173       for (int j = 0; j < dims.length; j++) {
174         int dim = dims[j];
175         String JavaDoc value = subItem.getNonGroupingDimensionValues()[j];
176         if (value != null && !value.equals("")) {
177           item.setAttribute(getTagName(dim), value);
178         }
179       }
180       for (int j = 0; j < mets.length; j++) {
181         SharedFloat value = subItem.getMetricValues()[j];
182         item.setAttribute(getMetricNameFromIndex(j), value.toString());
183       }
184
185
186       for (int j = 0; j < accmets.length; j++) {
187         SharedFloat value = subItem.getAccumulableMetricValues()[j];
188         item.setAttribute(getMetricNameFromIndex(subItem.getMetricIndex(j)) + "_ACC", value.toString());
189       }
190
191     }
192   }
193   /*private void fillNoGroupingValues(DataTreeNode dataTreeNode, Node element) {
194     int[] dims = getStaticReportData().getDataTree().getQuery().getNoGroupDimensions();
195     int[] mets = getStaticReportData().getDataTree().getQuery().getMetrics();
196     for (int i = 0; i < dataTreeNode.getSubItems().size(); i++) {
197       DataTreeSubItem subItem = (DataTreeSubItem) dataTreeNode.getSubItems().get(i);
198       Element item = createNodeElement("Item", "");
199       element.appendChild(item);
200       for (int j = 0; j < dims.length; j++) {
201         int dim = dims[j];
202         String value = subItem.getNonGroupingDimensionValues()[j];
203         if (value != null && !value.equals("")) {
204           item.setAttribute(getTagName(dim), value);
205         }
206       }
207       for (int j = 0; j < mets.length; j++) {
208         int met = mets[j];
209         CubeFloat value = subItem.getMetricValues()[j];
210         item.setAttribute(getMetricNameFromIndex(met), value.toString());
211       }
212     }
213   } */
214
215   /**
216    * Genera los atributos para un nodo del XML siempre y cuando
217    * la lista subItems del nodo contenga informacion.
218    * @param dataTreeNode
219    * @param element
220    */
221   private void fillMetrics(DataTreeNode dataTreeNode, Node JavaDoc element) {
222     //int[] mets = getStaticReportData().getDataTree().getQuery().getMetrics();
223 Object JavaDoc[] metrics = dataTreeNode.getMetrics();
224     for (int i = 0; i < metrics.length; i++) {
225       SharedFloat metric = (SharedFloat) metrics[i];
226       ((Element JavaDoc) element).setAttribute(getMetricNameFromIndex(i), metric.toString());
227     }
228
229     //int[] accmets = getStaticReportData().getDataTree().getQuery().getAccumulableMetrics();
230 /*Object[] accmetrics = dataTreeNode.getAccumulableMetrics();
231     for (int i = 0; i < accmetrics.length; i++) {
232       CubeFloat accmetric = (CubeFloat) accmetrics[i];
233       ((Element) element).setAttribute(getMetricNameFromIndex(i), accmetric.toString());
234     } */
235
236   }
237
238   /**
239    * Devuelve el nombre de una metrica a partir de un indice.
240    * @param metricIndex
241    * @return
242    */
243   private String JavaDoc getMetricNameFromIndex(int metricIndex) {
244
245     return ((ReportMetricSpec) reportSpec.getMetricsByIndex().get(metricIndex)).getName();
246   // return ((QueryMetric) reportData.getQuery().getMetrics().get(metric)).getName();
247 }
248
249
250   /**
251    * Serializa a disco el archivo XML de salida.
252    * @return
253    * @throws IOException
254    */
255   private StringWriter JavaDoc getStream() throws IOException JavaDoc {
256     OutputFormat format = new OutputFormat(document, "ISO-8859-1", true);
257     StringWriter JavaDoc stringOut = new StringWriter JavaDoc();
258     XMLSerializer serial = new XMLSerializer(stringOut, format);
259     serial.asDOMSerializer();
260     Element JavaDoc elem = document.getDocumentElement();
261     if (elem != null) {
262       serial.serialize(elem);
263     }
264     return stringOut;
265   }
266
267   /**
268    * Crea y retorna un nodo con las descripciones pasadas por parametro.
269    * @param tagName
270    * @param value
271    * @return
272    */
273   private Element JavaDoc createNodeElement(String JavaDoc tagName, String JavaDoc value) {
274     Element JavaDoc newElem;
275     newElem = document.createElement(tagName);
276     newElem.setAttribute("Value", value);
277     return newElem;
278   }
279
280 }
281
Popular Tags