Пример #1
0
        /// <summary>
        /// Initializes a new instance of the <see cref="GridReportDataView"/> class.
        /// </summary>
        /// <param name="report">The report.</param>
        /// <exception cref="System.ArgumentNullException"></exception>
        /// <exception cref="System.ArgumentException">Invalid report object to load the report</exception>
        public GridReportDataView(Report report)
        {
            if (report == null)
            {
                throw new ArgumentNullException();
            }

            // Get a conversion context
            var converter = Factory.Current.Resolve <IReportToQueryPartsConverter>();
            IReportToQueryContext context = converter.CreateContext(report);

            // If the report to load up the structured query from is still not an entity model thing then something bad has happened so throw up.
            if (report.RootNode == null)
            {
                throw new ArgumentException("Invalid report object to load the report");
            }
            // Build the list of report column formats
            ColumnFormats = ReportingEntityHelper.BuildColumnFormats(report.ReportColumns, context);

            // Then build the list of grouped columns (for client aggregates soon to be just aggregates)
            // This functionality is not defined just yet so we will leave it for now)

            // Done.
        }
        /// <summary>
        /// Builds the column format rules for the report columns.
        /// </summary>
        /// <param name="reportColumns">The report columns.</param>
        /// <param name="context">The context.</param>
        /// <returns>
        /// List{ColumnFormatting}.
        /// </returns>
        internal static List <ColumnFormatting> BuildColumnFormats(IEntityCollection <ReportColumn> reportColumns, IReportToQueryContext context)
        {
            List <ColumnFormatting> reportColumnFormats = new List <ColumnFormatting>();

            foreach (ReportColumn reportColumn in reportColumns)
            {
                ColumnFormatting columnFormatting = null;
                if (reportColumn.ColumnDisplayFormat != null && reportColumn.ColumnExpression != null)
                {
                    Formatting.ImageFormattingRule imageFormattingRule = null;
                    if (reportColumn.ColumnDisplayFormat.FormatImageScale != null &&
                        reportColumn.ColumnDisplayFormat.FormatImageSize != null)
                    {
                        imageFormattingRule = new Formatting.ImageFormattingRule
                        {
                            ThumbnailSizeId  = new Model.EntityRef(reportColumn.ColumnDisplayFormat.FormatImageSize.Id),
                            ThumbnailScaleId = new Model.EntityRef(reportColumn.ColumnDisplayFormat.FormatImageScale.Id),
                        };
                    }


                    columnFormatting = new ColumnFormatting
                    {
                        EntityId             = reportColumn.Id,
                        ColumnName           = reportColumn.Name,
                        DecimalPlaces        = reportColumn.ColumnDisplayFormat.FormatDecimalPlaces ?? 0,
                        ShowText             = reportColumn.ColumnDisplayFormat.ColumnShowText ?? false,
                        DisableDefaultFormat = reportColumn.ColumnDisplayFormat.DisableDefaultFormat ?? false,
                        Prefix         = reportColumn.ColumnDisplayFormat.FormatPrefix,
                        Suffix         = reportColumn.ColumnDisplayFormat.FormatSuffix,
                        Lines          = reportColumn.ColumnDisplayFormat.MaxLineCount ?? 0,
                        FormattingRule = imageFormattingRule ?? null
                    };
                    // Column Type
                    columnFormatting.ColumnType = TypedValueHelper.GetDatabaseType(reportColumn.ColumnExpression.ReportExpressionResultType);

                    DisplayFormat displayFormat = reportColumn.ColumnDisplayFormat;
                    // Format String
                    if (displayFormat.DateColumnFormat != null)
                    {
                        columnFormatting.DateFormat = displayFormat.DateColumnFormat;
                    }
                    if (displayFormat.DateTimeColumnFormat != null)
                    {
                        columnFormatting.DateTimeFormat = displayFormat.DateTimeColumnFormat;
                    }
                    if (displayFormat.TimeColumnFormat != null)
                    {
                        columnFormatting.TimeFormat = displayFormat.TimeColumnFormat;
                    }

                    // Text Alignment
                    if (displayFormat.FormatAlignment != null)
                    {
                        columnFormatting.Alignment = displayFormat.FormatAlignment;
                    }

                    if (displayFormat.EntityListColumnFormat != null)
                    {
                        columnFormatting.EntityListColumnFormat = displayFormat.EntityListColumnFormat;
                    }
                }
                // Formatting Rule
                if (reportColumn.ColumnFormattingRule != null && reportColumn.ColumnExpression != null)
                {
                    if (columnFormatting == null)
                    {
                        columnFormatting = new ColumnFormatting
                        {
                            EntityId   = reportColumn.Id,
                            ColumnName = reportColumn.Name,
                        }
                    }
                    ;
                    columnFormatting.FormattingRule = BuildColumnFormatRule(reportColumn.ColumnFormattingRule, columnFormatting.ColumnType, context);
                }

                if (columnFormatting != null && reportColumn.ColumnExpression != null)
                {
                    reportColumnFormats.Add(columnFormatting);
                }
            }

            return(reportColumnFormats);
        }
        private static Formatting.FormattingRule BuildColumnFormatRule(Model.FormattingRule formattingRule, DatabaseType columnType, IReportToQueryContext context)
        {
            var converter = Factory.Current.Resolve <IReportToQueryPartsConverter>( );

            if (formattingRule.Is <Model.BarFormattingRule>())
            {
                Model.BarFormattingRule      barRule           = formattingRule.As <Model.BarFormattingRule>();
                Formatting.BarFormattingRule barFormattingRule = new Formatting.BarFormattingRule()
                {
                    Color = ColourFromString(barRule.BarColor)
                };
                List <TypedValue> value = TypedValueHelper.TypedValueFromEntity(barRule.BarMinValue);
                if (value != null && value.Count > 0)
                {
                    barFormattingRule.Minimum = value[0];
                }
                value = TypedValueHelper.TypedValueFromEntity(barRule.BarMaxValue);
                if (value != null && value.Count > 0)
                {
                    barFormattingRule.Maximum = value[0];
                }
                return(barFormattingRule);
            }
            if (formattingRule.Is <Model.ColorFormattingRule>())
            {
                Model.ColorFormattingRule modelColourRule = formattingRule.As <Model.ColorFormattingRule>();
                List <ColorRule>          colourRules     = modelColourRule.ColorRules.Count > 0 ?
                                                            modelColourRule.ColorRules.OrderBy(rule => rule.RulePriority ?? 0).Select(colorRule => new ColorRule
                {
                    BackgroundColor = ColourFromString(colorRule.ColorRuleBackground),
                    ForegroundColor = ColourFromString(colorRule.ColorRuleForeground),
                    Condition       = converter.ConvertCondition(colorRule.RuleCondition, columnType, context)
                }).ToList()
                                                             : null;
                Formatting.ColorFormattingRule colourFormattingRule = new Formatting.ColorFormattingRule
                {
                    Rules = colourRules
                };
                return(colourFormattingRule);
            }
            if (formattingRule.Is <Model.IconFormattingRule>())
            {
                Model.IconFormattingRule modelIconFormattingRule = formattingRule.As <Model.IconFormattingRule>();
                return(new Formatting.IconFormattingRule
                {
                    Rules = modelIconFormattingRule.IconRules.OrderBy(rule => rule.RulePriority ?? 0).Select(rule => new Formatting.IconRule
                    {
                        CfEntityId = rule.IconRuleCFIcon != null ? rule.IconRuleCFIcon.Id: -1,
                        IconId = GetIconId(rule),
                        Condition = converter.ConvertCondition(rule.RuleCondition, columnType, context)
                    }).ToList()
                });
            }
            return(null);
        }