/// <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);
}
}
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);
}
}
}
}
/// <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);
}
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);
}
}
