/// <summary> /// Recursively walks the provided element and all children until it finds the first instance of an element /// implementing the <see cref="IMultipleRowsProducer"/> interface, which it then returns. /// See documentation for further information. /// </summary> /// <remarks>This is helpful for exporters that export to a format where no free-form output is possible. /// Examples include the CSV exporter or an exporter that exports to a spreadsheet.</remarks> /// <param name="element">The element to search recursively.</param> /// <returns>An object representing the found element. -or- null, if no such element was found.</returns> /// <exception cref="ArgumentNullException"><paramref name="element"/> was null.</exception> public static IMultipleRowsProducer FindFirstMultipleRowsProducer(this ICompositionElement element) { if (element == null) { throw new ArgumentNullException("element"); } IMultipleRowsProducer prod = null; prod = element as IMultipleRowsProducer; if (prod != null) { return(prod); } if (element.ChildrenSupported) { foreach (ICompositionElement child in element.Children) { prod = FindFirstMultipleRowsProducer(child); if (prod != null) { return(prod); } } } return(null); }
private void ExportSection(TextWriter writer, IReportTemplateSection section, IGenerationContext context) { /* This searches for the first occurrence of a multiple rows producer. * CSV format is very limited and it makes no sense to export more tables or just a single value. */ IMultipleRowsProducer producer = section.RootElement.FindFirstMultipleRowsProducer(); if (producer != null) { DataRow[] rows = producer.GetValue(context).ToArray(); if (rows.Length > 0) { /* Write header row. */ writer.WriteLine(string.Join(";", rows.First().Table.Columns.Cast <DataColumn>().Select(_ => _.ColumnName))); /* Write data. */ foreach (DataRow row in rows) { writer.WriteLine(string.Join(";", row.ItemArray)); } } } }
private void WriteTable(IMultipleRowsProducer rp, Table table, IGenerationContext context) { DataRow[] rows = rp.GetValue(context).ToArray(); if (rows.Length > 0) { DataTable ptab = rows.First().Table; for (int iCol = 0; iCol < ptab.Columns.Count; iCol++) { table.ColumnCollection.Add(new Column(table, string.Empty)); } for (int iRow = -1; iRow < rows.Length; iRow++) { Row row = new Row(table); table.RowCollection.Add(row); for (int iCol = 0; iCol < ptab.Columns.Count; iCol++) { Cell cell = new Cell(table); object value = (iRow == -1) ? ptab.Columns[iCol].ColumnName : rows[iRow][iCol]; CreateAddSimpleText(table.Document, cell.Content, value); row.CellCollection.Add(cell); } } } }
private void WriteTable(IMultipleRowsProducer rp, IGenerationContext context, IDocument doc) { DataRow[] rows = rp.GetValue(context).ToArray(); if (rows.Length > 0) { DataTable ptab = rows.First().Table; Table table = TableBuilder.CreateTextDocumentTable((TextDocument)doc, ptab.TableName, string.Empty, rows.Length + 1, ptab.Columns.Count, 0d, true, true); CellCollection tableCells = table.RowHeader.RowCollection[0].CellCollection; for (int i = 0; i < tableCells.Count; i++) { CreateAddSimpleText(doc, tableCells[i].Content, ptab.Columns[i].ColumnName); } for (int i = 0; i < table.RowCollection.Count; i++) { tableCells = table.RowCollection[i].CellCollection; for (int j = 0; j < tableCells.Count; j++) { CreateAddSimpleText(doc, tableCells[j].Content, rows[i][j]); } } doc.Content.Add(table); } }
/// <summary> /// Overridden. /// </summary> /// <param name="element"></param> /// <param name="doc"></param> /// <param name="level"></param> protected override void OnWriteElement(ICompositionElement element, IGenerationContext context, IDocument doc, int level) { IScalarValueProducer singleValue = element as IScalarValueProducer; if (singleValue != null) { CreateAddSimpleText(doc, doc.Content, singleValue.GetValue(context)); } else { IMultipleRowsProducer rp = element as IMultipleRowsProducer; if (rp != null) { WriteTable(rp, context, doc); } } }
/// <summary> /// Exports the provided report template to an ODS document. /// </summary> /// <param name="context"></param> /// <returns></returns> protected override Stream Export(IGenerationContext context) { IReportTemplateSection sdet = context.Template.Sections.GetSection(SectionType.Detail); SpreadsheetDocument doc = new SpreadsheetDocument(); doc.New(); IMultipleRowsProducer producer = sdet.RootElement.FindFirstMultipleRowsProducer(); if (producer != null) { Table table = TableBuilder.CreateSpreadsheetTable(doc, "Table", string.Empty); doc.Content.Add(table); WriteTable(producer, table, context); } return(CreateStream(doc)); }
private void WriteElement(ICompositionElement element, XElement parent, IGenerationContext context) { XElement el = CreateTag(TagType.Div); if (element.ChildrenSupported) { foreach (ICompositionElement child in element.Children) { WriteElement(child, el, context); } } IScalarValueProducer singleValue = element as IScalarValueProducer; if (singleValue != null) { XElement elValue = CreateTag(TagType.Span); elValue.Add(new XAttribute("class", "value")); elValue.Add(singleValue.GetValue(context)); el.Add(elValue); } else { IMultipleRowsProducer rows = element as IMultipleRowsProducer; if (rows != null) { XElement elTable = CreateTag(TagType.Table); XElement elTableHeader = null; foreach (DataRow row in rows.GetValue(context)) { if (elTableHeader == null) { elTableHeader = CreateTag(TagType.TableHeader); XElement elTableHeaderRow = CreateTag(TagType.TableRow); foreach (DataColumn col in row.Table.Columns) { elTableHeaderRow.Add(new XElement(GetTagName(TagType.TableColumn), new XText(col.ColumnName))); } elTableHeader.Add(elTableHeaderRow); elTable.Add(elTableHeader); } XElement elRow = CreateTag(TagType.TableRow); foreach (object colValue in row.ItemArray) { XElement elColValue = CreateTag(TagType.Span); elColValue.Add(new XAttribute("class", "value")); elColValue.Add(colValue); elRow.Add(new XElement(GetTagName(TagType.TableColumn), elColValue)); } elTable.Add(elRow); } el.Add(elTable); } else { if (element.Classification.HasFlag(ElementClassifications.Separator)) { el.Name = GetTagName(TagType.HorizontalRule); } double height = element.GetProperty("height", double.NaN); if (!double.IsNaN(height)) { ApplyClass(el, "height-" + height.ToString()); } } } parent.Add(el); }