Exemplo n.º 1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="reportData"></param>
        /// <param name="options"></param>
        /// <returns></returns>
        public override TableDefinition Content(ReportData reportData, Dictionary <string, string> options)
        {
            string srBusinessCriterias = (options != null && options.ContainsKey("PAR")) ? options["PAR"] : null;
            int    count;

            if (options == null || !options.ContainsKey("COUNT") || !int.TryParse(options["COUNT"], out count))
            {
                count = -1;
            }

            if (string.IsNullOrWhiteSpace(srBusinessCriterias))
            {
                return(null);
            }
            // Parse business criterias Ids
            List <int> businessCriteriasIds = new List <int>();

            string[] parentMetrics = srBusinessCriterias.Split('|');
            foreach (var metric in parentMetrics.Distinct())
            {
                int metricId;
                if (int.TryParse(metric, out metricId))
                {
                    businessCriteriasIds.Add(metricId);
                }
            }

            //Build result
            List <string> rowData = new List <string>();

            rowData.AddRange(new[] { Labels.Criticality, Labels.Weight, Labels.Grade, Labels.TechnicalCriterion, Labels.RuleName, Labels.ViolCount, Labels.TotalOk });

            var results = RulesViolationUtility.GetNbViolationByRule(reportData.CurrentSnapshot, reportData.RuleExplorer, businessCriteriasIds, count);
            int nbRows  = 0;

            foreach (var item in results)
            {
                rowData.Add(item.Rule.Critical ? "µ" : string.Empty);
                rowData.Add(item.Rule.CompoundedWeight.ToString());
                rowData.Add(item.Grade?.ToString("N2"));
                rowData.Add(item.TechnicalCriteraiName);
                rowData.Add(item.Rule.Name);

                rowData.Add(item.TotalFailed.HasValue ? item.TotalFailed.Value.ToString("N0") : Constants.No_Value);
                rowData.Add(item.TotalChecks.HasValue ? item.TotalChecks.Value.ToString("N0") : Constants.No_Value);

                nbRows++;
            }

            TableDefinition resultTable = new TableDefinition
            {
                HasRowHeaders    = false,
                HasColumnHeaders = true,
                NbRows           = nbRows + 1,
                NbColumns        = 7,
                Data             = rowData
            };

            return(resultTable);
        }
Exemplo n.º 2
0
        public override TableDefinition Content(ReportData reportData, Dictionary <string, string> options)
        {
            int           rowCount = 0;
            List <string> rowData  = new List <string>();
            List <RuleViolationsVariationResultDTO> variationRules = new List <RuleViolationsVariationResultDTO>();

            rowData.AddRange(new[] {
                Labels.Weight,
                Labels.Variation,
                Labels.RuleName
            });

            List <string> bcIdsStr = options.GetOption("BCID", "60017").Split('|').ToList();
            List <int>    bcIds    = bcIdsStr.Select(int.Parse).ToList();

            // to get decrease by default
            bool increase = options.GetOption("VARIATION", "DECREASE").ToLower().Equals("increase");
            // to get number by default
            bool percent = options.GetOption("DATA", "NUMBER").ToLower().Equals("percent");

            int nbLimitTop = options.GetIntOption("COUNT", 50);

            if (reportData?.CurrentSnapshot != null)
            {
                List <RuleViolationResultDTO> currentCriticalRulesViolation =
                    RulesViolationUtility.GetNbViolationByRule(reportData.CurrentSnapshot, reportData.RuleExplorer, bcIds, -1);

                List <RuleViolationResultDTO> previousCriticalRulesViolation = (reportData.PreviousSnapshot != null) ?
                                                                               RulesViolationUtility.GetNbViolationByRule(reportData.PreviousSnapshot, reportData.RuleExplorer, bcIds, -1)
                    : null;

                if (currentCriticalRulesViolation != null && previousCriticalRulesViolation != null)
                {
                    if (increase)
                    {
                        foreach (RuleViolationResultDTO item in currentCriticalRulesViolation)
                        {
                            RuleViolationResultDTO previousitem = previousCriticalRulesViolation.FirstOrDefault(_ => _.Rule.Key == item.Rule.Key);
                            double?variation;

                            if (previousitem != null)
                            {
                                if (item.TotalChecks != null && previousitem.TotalChecks != null)
                                {
                                    variation = percent
                                        ? item.TotalFailed / (double)item.TotalChecks - previousitem.TotalFailed / (double)previousitem.TotalChecks
                                        : item.TotalFailed - previousitem.TotalFailed;
                                    if (variation <= 0)
                                    {
                                        continue;
                                    }
                                }
                                else
                                {
                                    continue;
                                }
                            }
                            else
                            {
                                if (item.TotalChecks != null)
                                {
                                    variation = percent
                                        ? item.TotalFailed / (double)item.TotalChecks
                                        : item.TotalFailed;
                                    if (variation <= 0)
                                    {
                                        continue;
                                    }
                                }
                                else
                                {
                                    continue;
                                }
                            }

                            variationRules.Add(new RuleViolationsVariationResultDTO
                            {
                                Rule = new RuleDetailsDTO {
                                    Name = item.Rule.Name, Key = item.Rule.Key, CompoundedWeight = item.Rule.CompoundedWeight
                                },
                                CurrentNbViolations  = item.TotalFailed ?? -1,
                                PreviousNbViolations = previousitem?.TotalFailed ?? -1,
                                Variation            = variation ?? double.NaN
                            });
                        }
                    }
                    else
                    {
                        foreach (RuleViolationResultDTO previousitem in previousCriticalRulesViolation)
                        {
                            RuleViolationResultDTO item = currentCriticalRulesViolation.FirstOrDefault(_ => _.Rule.Key == previousitem.Rule.Key);
                            double?variation;

                            if (item != null)
                            {
                                if (previousitem.TotalChecks != null && item.TotalChecks != null)
                                {
                                    variation = percent
                                        ? previousitem.TotalFailed / (double)previousitem.TotalChecks - item.TotalFailed / (double)item.TotalChecks
                                        : previousitem.TotalFailed - item.TotalFailed;
                                    if (variation <= 0)
                                    {
                                        continue;
                                    }
                                }
                                else
                                {
                                    continue;
                                }
                            }
                            else
                            {
                                if (previousitem.TotalChecks != null)
                                {
                                    variation = percent
                                        ? previousitem.TotalFailed / (double)previousitem.TotalChecks
                                        : previousitem.TotalFailed;
                                    if (variation <= 0)
                                    {
                                        continue;
                                    }
                                }
                                else
                                {
                                    continue;
                                }
                            }

                            variationRules.Add(new RuleViolationsVariationResultDTO
                            {
                                Rule = new RuleDetailsDTO {
                                    Name = previousitem.Rule.Name, Key = previousitem.Rule.Key, CompoundedWeight = previousitem.Rule.CompoundedWeight
                                },
                                CurrentNbViolations  = item?.TotalFailed ?? -1,
                                PreviousNbViolations = previousitem.TotalFailed ?? -1,
                                Variation            = variation ?? double.NaN
                            });
                        }
                    }

                    List <RuleViolationsVariationResultDTO> selected_elements = nbLimitTop != -1 ? variationRules.OrderByDescending(_ => _.Variation).Take(nbLimitTop).ToList() : variationRules.OrderByDescending(_ => _.Variation).ToList();
                    if (selected_elements.Count <= 0)
                    {
                        rowData.AddRange(new[]
                        {
                            Labels.NoItem,
                            string.Empty,
                            string.Empty
                        });
                        rowCount = 1;
                    }
                    else
                    {
                        foreach (RuleViolationsVariationResultDTO varRule in selected_elements)
                        {
                            rowData.AddRange(new[]
                            {
                                varRule.Rule.CompoundedWeight.ToString(),
                                percent ? FormatPercent(varRule.Variation) : varRule.Variation.ToString(),
                                varRule.Rule.Name
                            }
                                             );
                            rowCount++;
                        }
                    }
                }
                else
                {
                    rowData.AddRange(new[]
                    {
                        Labels.NoItem,
                        string.Empty,
                        string.Empty
                    });
                    rowCount = 1;
                }
            }

            var resultTable = new TableDefinition {
                HasRowHeaders    = false,
                HasColumnHeaders = true,
                NbRows           = rowCount + 1,
                NbColumns        = 3,
                Data             = rowData
            };

            return(resultTable);
        }