示例#1
0
        /// <summary>
        /// Fills document with data
        /// </summary>
        /// <exception cref="InvalidDataException">ReportTableRow must have a TableRowGroup as parent</exception>
        protected virtual void FillData()
        {
            ArrayList blockDocumentValues  = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(IInlineDocumentValue));  // walker.Walk<IInlineDocumentValue>(_flowDocument);
            ArrayList blockTableRows       = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(ITableRowForDataTable)); // walker.Walk<TableRowForDataTable>(_flowDocument);
            ArrayList blockAggregateValues = _dynamicCache.GetFlowDocumentVisualListByType(typeof(InlineAggregateValue));       // walker.Walk<InlineAggregateValue>(_flowDocument);
            ArrayList charts = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(IChart));                              // walker.Walk<IChart>(_flowDocument);
            ArrayList dynamicHeaderTableRows = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(ITableRowForDynamicHeader));
            ArrayList dynamicDataTableRows   = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(ITableRowForDynamicDataTable));
            ArrayList documentConditions     = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(IDocumentCondition));

            List <Block> blocks = new List <Block>();

            if (_blockPageHeader != null)
            {
                blocks.Add(_blockPageHeader);
            }
            if (_blockPageFooter != null)
            {
                blocks.Add(_blockPageFooter);
            }

            DocumentWalker walker = new DocumentWalker();

            blockDocumentValues.AddRange(walker.TraverseBlockCollection <IInlineDocumentValue>(blocks));

            Dictionary <string, List <object> > aggregateValues = new Dictionary <string, List <object> >();

            FillCharts(charts);

            // hide conditional text blocks
            foreach (IDocumentCondition dc in documentConditions)
            {
                if (dc == null)
                {
                    continue;
                }
                dc.PerformRenderUpdate(_data);
            }

            // fill report values
            foreach (IInlineDocumentValue dv in blockDocumentValues)
            {
                if (dv == null)
                {
                    continue;
                }
                object obj;
                if ((dv.PropertyName != null) && (_data.ReportDocumentValues.TryGetValue(dv.PropertyName, out obj)))
                {
                    dv.Value = obj;
                    RememberAggregateValue(aggregateValues, dv.AggregateGroup, obj);
                }
                else
                {
                    if ((_data.ShowUnknownValues) && (dv.Value == null))
                    {
                        dv.Value = "[" + ((dv.PropertyName != null) ? dv.PropertyName : "NULL") + "]";
                    }
                    RememberAggregateValue(aggregateValues, dv.AggregateGroup, null);
                }
            }

            // fill dynamic tables
            foreach (ITableRowForDynamicDataTable iTableRow in dynamicDataTableRows)
            {
                TableRow tableRow = iTableRow as TableRow;
                if (tableRow == null)
                {
                    continue;
                }

                TableRowGroup tableGroup = tableRow.Parent as TableRowGroup;
                if (tableGroup == null)
                {
                    continue;
                }

                TableRow currentRow;

                DataTable table = _data.GetDataTableByName(iTableRow.TableName);

                for (int i = 0; i < table.Rows.Count; i++)
                {
                    currentRow = new TableRow();

                    DataRow dataRow = table.Rows[i];
                    for (int j = 0; j < table.Columns.Count; j++)
                    {
                        string value = dataRow[j].ToString();
                        currentRow.Cells.Add(new TableCell(new Paragraph(new Run(value))));
                    }
                    tableGroup.Rows.Add(currentRow);
                }
            }

            foreach (ITableRowForDynamicHeader iTableRow in dynamicHeaderTableRows)
            {
                TableRow tableRow = iTableRow as TableRow;
                if (tableRow == null)
                {
                    continue;
                }

                DataTable table = _data.GetDataTableByName(iTableRow.TableName);

                foreach (DataRow row in table.Rows)
                {
                    string    value     = row[0].ToString();
                    TableCell tableCell = new TableCell(new Paragraph(new Run(value)));
                    tableRow.Cells.Add(tableCell);
                }
            }

            // group table row groups
            Dictionary <TableRowGroup, List <TableRow> > groupedRows = new Dictionary <TableRowGroup, List <TableRow> >();
            Dictionary <TableRowGroup, string>           tableNames  = new Dictionary <TableRowGroup, string>();

            foreach (TableRow tableRow in blockTableRows)
            {
                TableRowGroup rowGroup = tableRow.Parent as TableRowGroup;
                if (rowGroup == null)
                {
                    continue;
                }

                ITableRowForDataTable iTableRow = tableRow as ITableRowForDataTable;
                if ((iTableRow != null) && (iTableRow.TableName != null))
                {
                    string tableName;
                    if (tableNames.TryGetValue(rowGroup, out tableName))
                    {
                        if (tableName != iTableRow.TableName.Trim().ToLowerInvariant())
                        {
                            throw new ReportingException("TableRowGroup cannot be mapped to different DataTables in TableRowForDataTable");
                        }
                    }
                    else
                    {
                        tableNames[rowGroup] = iTableRow.TableName.Trim().ToLowerInvariant();
                    }
                }

                List <TableRow> rows;
                if (!groupedRows.TryGetValue(rowGroup, out rows))
                {
                    rows = new List <TableRow>();
                    groupedRows[rowGroup] = rows;
                }
                rows.Add(tableRow);
            }

            // fill tables
            foreach (KeyValuePair <TableRowGroup, List <TableRow> > groupedRow in groupedRows)
            {
                TableRowGroup rowGroup = groupedRow.Key;

                ITableRowForDataTable iTableRow = groupedRow.Value[0] as ITableRowForDataTable;
                if (iTableRow == null)
                {
                    continue;
                }

                DataTable table = _data.GetDataTableByName(iTableRow.TableName);
                if (table == null)
                {
                    if (_data.ShowUnknownValues)
                    {
                        // show unknown values
                        foreach (TableRow tableRow in groupedRow.Value)
                        {
                            foreach (TableCell cell in tableRow.Cells)
                            {
                                DocumentWalker         localWalker = new DocumentWalker();
                                List <ITableCellValue> tableCells  = localWalker.TraverseBlockCollection <ITableCellValue>(cell.Blocks);
                                foreach (ITableCellValue cv in tableCells)
                                {
                                    IPropertyValue dv = cv as IPropertyValue;
                                    if (dv == null)
                                    {
                                        continue;
                                    }
                                    dv.Value = "[" + dv.PropertyName + "]";
                                    RememberAggregateValue(aggregateValues, cv.AggregateGroup, null);
                                }
                            }
                        }
                    }
                    else
                    {
                        continue;
                    }
                }
                else
                {
                    List <TableRow> listNewRows = new List <TableRow>();
                    TableRow        newTableRow;

                    // clone XAML rows
                    List <string> clonedRows = new List <string>();
                    foreach (TableRow row in rowGroup.Rows)
                    {
                        TableRowForDataTable reportTableRow = row as TableRowForDataTable;
                        if (reportTableRow == null)
                        {
                            clonedRows.Add(null);
                        }
                        clonedRows.Add(XamlWriter.Save(reportTableRow));
                    }

                    for (int i = 0; i < table.Rows.Count; i++)
                    {
                        DataRow dataRow = table.Rows[i];

                        for (int j = 0; j < rowGroup.Rows.Count; j++)
                        {
                            TableRow row = rowGroup.Rows[j];

                            TableRowForDataTable reportTableRow = row as TableRowForDataTable;
                            if (reportTableRow == null)
                            {
                                // clone regular row
                                listNewRows.Add(XamlHelper.CloneTableRow(row));
                            }
                            else
                            {
                                // clone ReportTableRows
                                newTableRow = (TableRow)XamlHelper.LoadXamlFromString(clonedRows[j]);

                                foreach (TableCell cell in newTableRow.Cells)
                                {
                                    DocumentWalker         localWalker = new DocumentWalker();
                                    List <ITableCellValue> newCells    = localWalker.TraverseBlockCollection <ITableCellValue>(cell.Blocks);
                                    foreach (ITableCellValue cv in newCells)
                                    {
                                        IPropertyValue dv = cv as IPropertyValue;
                                        if (dv == null)
                                        {
                                            continue;
                                        }
                                        try
                                        {
                                            object obj = dataRow[dv.PropertyName];
                                            if (obj == DBNull.Value)
                                            {
                                                obj = null;
                                            }
                                            dv.Value = obj;

                                            RememberAggregateValue(aggregateValues, cv.AggregateGroup, obj);
                                        }
                                        catch
                                        {
                                            if (_data.ShowUnknownValues)
                                            {
                                                dv.Value = "[" + dv.PropertyName + "]";
                                            }
                                            else
                                            {
                                                dv.Value = "";
                                            }
                                            RememberAggregateValue(aggregateValues, cv.AggregateGroup, null);
                                        }
                                    }
                                }
                                listNewRows.Add(newTableRow);

                                // fire event
                                _report.FireEventDataRowBoundEventArgs(new DataRowBoundEventArgs(_report, dataRow)
                                {
                                    TableName = dataRow.Table.TableName, TableRow = newTableRow
                                });
                            }
                        }
                    }
                    rowGroup.Rows.Clear();
                    foreach (TableRow row in listNewRows)
                    {
                        rowGroup.Rows.Add(row);
                    }
                }
            }

            // fill aggregate values
            foreach (InlineAggregateValue av in blockAggregateValues)
            {
                if (String.IsNullOrEmpty(av.AggregateGroup))
                {
                    continue;
                }

                string[] aggregateGroups = av.AggregateGroup.Split(new char[] { ',', ';', ' ' }, StringSplitOptions.RemoveEmptyEntries);

                foreach (var group in aggregateGroups)
                {
                    if (!aggregateValues.ContainsKey(group))
                    {
                        av.Text = av.EmptyValue;
                        break;
                    }
                }
                av.Text = av.ComputeAndFormat(aggregateValues);
            }
        }
示例#2
0
        /// <summary>
        /// Fills document with data
        /// </summary>
        /// <exception cref="InvalidDataException">ReportTableRow must have a TableRowGroup as parent</exception>
        protected virtual void FillData()
        {
            ArrayList blockDocumentValues  = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(IInlineDocumentValue));  // walker.Walk<IInlineDocumentValue>(_flowDocument);
            ArrayList blockTableRows       = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(ITableRowForDataTable)); // walker.Walk<TableRowForDataTable>(_flowDocument);
            ArrayList blockAggregateValues = _dynamicCache.GetFlowDocumentVisualListByType(typeof(InlineAggregateValue));       // walker.Walk<InlineAggregateValue>(_flowDocument);
            ArrayList charts = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(IChart));                              // walker.Walk<IChart>(_flowDocument);
            ArrayList dynamicHeaderTableRows = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(ITableRowForDynamicHeader));
            ArrayList dynamicDataTableRows   = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(ITableRowForDynamicDataTable));


            List <Block> blocks = new List <Block>();

            if (_blockPageHeader != null)
            {
                blocks.Add(_blockPageHeader);
            }
            if (_blockPageFooter != null)
            {
                blocks.Add(_blockPageFooter);
            }

            DocumentWalker walker = new DocumentWalker();

            blockDocumentValues.AddRange(walker.TraverseBlockCollection <IInlineDocumentValue>(blocks));

            Dictionary <string, List <object> > aggregateValues = new Dictionary <string, List <object> >();

            FillCharts(charts);

            // fill report values
            foreach (IInlineDocumentValue dv in blockDocumentValues)
            {
                if (dv == null)
                {
                    continue;
                }
                object obj = null;
                if ((dv.PropertyName != null) && (_data.ReportDocumentValues.TryGetValue(dv.PropertyName, out obj)))
                {
                    dv.Value = obj;
                    RememberAggregateValue(aggregateValues, dv.AggregateGroup, obj);
                }
                else
                {
                    if ((_data.ShowUnknownValues) && (dv.Value == null))
                    {
                        dv.Value = "[" + ((dv.PropertyName != null) ? dv.PropertyName : "NULL") + "]";
                    }
                    RememberAggregateValue(aggregateValues, dv.AggregateGroup, null);
                }
            }


            // fill dynamic tables
            foreach (ITableRowForDynamicDataTable iTableRow in dynamicDataTableRows)
            {
                TableRow tableRow = iTableRow as TableRow;
                if (tableRow == null)
                {
                    continue;
                }

                TableRowGroup tableGroup = tableRow.Parent as TableRowGroup;
                if (tableGroup == null)
                {
                    continue;
                }

                TableRow currentRow = null;

                DataTable table = _data.GetDataTableByName(iTableRow.TableName);

                for (int i = 0; i < table.Rows.Count; i++)
                {
                    currentRow = new TableRow();

                    DataRow dataRow = table.Rows[i];
                    for (int j = 0; j < table.Columns.Count; j++)
                    {
                        string value = dataRow[j].ToString();
                        currentRow.Cells.Add(new TableCell(new Paragraph(new Run(value))));
                    }
                    tableGroup.Rows.Add(currentRow);
                }
            }

            foreach (ITableRowForDynamicHeader iTableRow in dynamicHeaderTableRows)
            {
                TableRow tableRow = iTableRow as TableRow;
                if (tableRow == null)
                {
                    continue;
                }

                DataTable table = _data.GetDataTableByName(iTableRow.TableName);

                foreach (DataRow row in table.Rows)
                {
                    string    value     = row[0].ToString();
                    TableCell tableCell = new TableCell(new Paragraph(new Run(value)));
                    tableRow.Cells.Add(tableCell);
                }
            }

            // fill tables
            foreach (ITableRowForDataTable iTableRow in blockTableRows)
            {
                TableRow tableRow = iTableRow as TableRow;
                if (tableRow == null)
                {
                    continue;
                }

                DataTable table = _data.GetDataTableByName(iTableRow.TableName);
                if (table == null)
                {
                    if (_data.ShowUnknownValues)
                    {
                        // show unknown values
                        foreach (TableCell cell in tableRow.Cells)
                        {
                            DocumentWalker         localWalker = new DocumentWalker();
                            List <ITableCellValue> tableCells  = localWalker.TraverseBlockCollection <ITableCellValue>(cell.Blocks);
                            foreach (ITableCellValue cv in tableCells)
                            {
                                IPropertyValue dv = cv as IPropertyValue;
                                if (dv == null)
                                {
                                    continue;
                                }
                                dv.Value = "[" + dv.PropertyName + "]";
                                IAggregateValue av = cv as IAggregateValue;
                                if (av != null)
                                {
                                    RememberAggregateValue(aggregateValues, av.AggregateGroup, null);
                                }
                            }
                        }
                    }
                    else
                    {
                        continue;
                    }
                }
                else
                {
                    List <ITableCellValue> tableCells = new List <ITableCellValue>();
                    foreach (TableCell cell in tableRow.Cells)
                    {
                        DocumentWalker localWalker = new DocumentWalker();
                        tableCells.AddRange(localWalker.TraverseBlockCollection <ITableCellValue>(cell.Blocks));
                    }

                    TableRowGroup rowGroup = tableRow.Parent as TableRowGroup;
                    if (rowGroup == null)
                    {
                        throw new InvalidDataException("ReportTableRow must have a TableRowGroup as parent");
                    }

                    List <TableRow> listNewRows = new List <TableRow>();
                    foreach (TableRow row in rowGroup.Rows)
                    {
                        TableRowForDataTable reportTableRow = row as TableRowForDataTable;
                        if (reportTableRow == null)
                        {
                            // clone regular row
                            listNewRows.Add(XamlHelper.CloneTableRow(row));
                        }
                        else
                        {
                            string reportTableRowXaml = XamlWriter.Save(reportTableRow);

                            // clone ReportTableRows
                            List <TableRow> clonedTableRows = new List <TableRow>();
                            for (int i = 0; i < table.Rows.Count; i++)
                            {
                                clonedTableRows.Add((TableRow)XamlHelper.LoadXamlFromString(reportTableRowXaml));
                            }

                            foreach (DataRow dataRow in table.Rows)
                            {
                                // get cloned ReportTableRow
                                TableRow newTableRow = clonedTableRows[0];
                                clonedTableRows.RemoveAt(0);

                                foreach (TableCell cell in newTableRow.Cells)
                                {
                                    DocumentWalker         localWalker = new DocumentWalker();
                                    List <ITableCellValue> newCells    = localWalker.TraverseBlockCollection <ITableCellValue>(cell.Blocks);
                                    foreach (ITableCellValue cv in newCells)
                                    {
                                        IPropertyValue dv = cv as IPropertyValue;
                                        if (dv == null)
                                        {
                                            continue;
                                        }
                                        IAggregateValue av = cv as IAggregateValue;
                                        try
                                        {
                                            object obj = dataRow[dv.PropertyName];
                                            if (obj == DBNull.Value)
                                            {
                                                obj = null;
                                            }
                                            dv.Value = obj;

                                            if (av != null)
                                            {
                                                RememberAggregateValue(aggregateValues, av.AggregateGroup, obj);
                                            }
                                        }
                                        catch
                                        {
                                            if (_data.ShowUnknownValues)
                                            {
                                                dv.Value = "[" + dv.PropertyName + "]";
                                            }
                                            else
                                            {
                                                dv.Value = "";
                                            }
                                            if (av != null)
                                            {
                                                RememberAggregateValue(aggregateValues, av.AggregateGroup, null);
                                            }
                                        }
                                    }
                                }
                                listNewRows.Add(newTableRow);

                                // fire event
                                _report.FireEventDataRowBoundEventArgs(new DataRowBoundEventArgs(_report, dataRow)
                                {
                                    TableName = dataRow.Table.TableName, TableRow = newTableRow
                                });
                            }
                        }
                    }
                    rowGroup.Rows.Clear();
                    foreach (TableRow row in listNewRows)
                    {
                        rowGroup.Rows.Add(row);
                    }
                }
            }

            // fill aggregate values
            foreach (InlineAggregateValue av in blockAggregateValues)
            {
                if (String.IsNullOrEmpty(av.AggregateGroup))
                {
                    continue;
                }
                if (!aggregateValues.ContainsKey(av.AggregateGroup))
                {
                    av.Text = av.EmptyValue;
                }
                else
                {
                    av.Text = av.ComputeAndFormat(aggregateValues);
                }
            }
        }