/// <summary>
///
/// </summary>
/// <param name="snapshot"></param>
/// <param name="rulesViolationType"></param>
/// <param name="businessCriteriaId"></param>
/// <returns></returns>
public static List <RuleViolationResultDTO> GetAllRuleViolations(Snapshot snapshot,
Constants.RulesViolation rulesViolationType,
Constants.BusinessCriteria businessCriteriaId,
bool onlyFailedChecks)
{
var query = GetQueryRuleViolations(snapshot, rulesViolationType, businessCriteriaId, onlyFailedChecks);
if (query != null)
{
return(query.Select(_ => new RuleViolationResultDTO
{
Rule = new RuleDetailsDTO {
Name = _.Reference.Name, Key = _.Reference.Key
},
TotalChecks = _.DetailResult.ViolationRatio.TotalChecks,
TotalFailed = _.DetailResult.ViolationRatio.FailedChecks,
Grade = _.DetailResult.Grade
})
.OrderByDescending(_ => _.TotalFailed)
.ToList());
}
else
{
return(null);
}
}
public ViolationSummaryDTO this[Constants.BusinessCriteria index]
{
get
{
return(Stats.FirstOrDefault(_ => _.BusinessCriteria.Equals(index)));
}
}
public ViolationsStatisticsDTO this[Constants.BusinessCriteria idx]
{
get
{
return(Stats.FirstOrDefault(_ => _.BusinessCriteria.Equals(idx)));
}
}
/// <summary>
///
/// </summary>
/// <param name="snapshot"></param>
/// <param name="rulesViolationType"></param>
/// <param name="businessCriteriaId"></param>
/// <param name="onlyFailedChecks"></param>
/// <returns></returns>
public static int?GetNbRuleWithViolations(Snapshot snapshot,
Constants.RulesViolation rulesViolationType,
Constants.BusinessCriteria businessCriteriaId,
bool onlyFailedChecks)
{
var query = GetQueryRuleViolations(snapshot, rulesViolationType, businessCriteriaId, onlyFailedChecks);
return(query?.Select(_ => _.Reference.HRef).Distinct().Count());
}
/// <summary>
/// Get TQI for snapshot
/// </summary>
/// <param name="snapshot"></param>
/// <param name="bcId"></param>
/// <param name="round"></param>
/// <returns></returns>
public static double?GetSnapshotBusinessCriteriaGrade(Snapshot snapshot, Constants.BusinessCriteria bcId, bool round)
{
double?res = null;
var resultBC = snapshot?.BusinessCriteriaResults?.SingleOrDefault(_ => _.Reference.Key == bcId.GetHashCode());
if (resultBC != null)
{
res = round ? MathUtility.GetRound(resultBC.DetailResult.Grade) : resultBC.DetailResult.Grade;
}
return(res);
}
/// <summary>
///
/// </summary>
/// <param name="snapshot"></param>
/// <param name="rulesViolationType"></param>
/// <param name="businessCriteriaId"></param>
/// <param name="onlyFailedChecks"></param>
/// <returns></returns>
private static IQueryable <ApplicationResult> GetQueryRuleViolations(Snapshot snapshot,
Constants.RulesViolation rulesViolationType,
Constants.BusinessCriteria businessCriteriaId,
bool onlyFailedChecks)
{
if (snapshot?.BusinessCriteriaResults == null)
{
return(null);
}
var query = snapshot.BusinessCriteriaResults.AsQueryable();
if (businessCriteriaId != 0)
{
query = query.Where(_ => _.Reference.Key == businessCriteriaId.GetHashCode());
}
// ReSharper disable once SwitchStatementMissingSomeCases
switch (rulesViolationType)
{
case Constants.RulesViolation.CriticalRulesViolation:
query = query.SelectMany(_ => _.CriticalRulesViolation);
break;
case Constants.RulesViolation.NonCriticalRulesViolation:
query = query.SelectMany(_ => _.NonCriticalRulesViolation);
break;
default:
query = query.SelectMany(_ => _.CriticalRulesViolation.Union(_.NonCriticalRulesViolation));
break;
}
query = (from bc in query
where bc.DetailResult != null &&
bc.DetailResult.ViolationRatio != null &&
(!onlyFailedChecks || bc.DetailResult.ViolationRatio.FailedChecks > 0)
select bc);
return(query);
}
/// <summary>
///
/// </summary>
/// <param name="snapshot"></param>
/// <param name="rulesViolationType"></param>
/// <param name="businessCriteriaId"></param>
/// <param name="onlyFailedChecks"></param>
/// <param name="nbTopResult"></param>
/// <returns></returns>
public static List <RuleViolationResultDTO> GetRuleViolations(Snapshot snapshot,
Constants.RulesViolation rulesViolationType,
Constants.BusinessCriteria businessCriteriaId,
bool onlyFailedChecks,
int nbTopResult)
{
var query = GetQueryRuleViolations(snapshot, rulesViolationType, businessCriteriaId, onlyFailedChecks);
return(query?.Select(_ => new RuleViolationResultDTO
{
Rule = new RuleDetailsDTO {
Name = _.Reference.Name, Key = _.Reference.Key
},
TotalChecks = _.DetailResult.ViolationRatio.TotalChecks,
TotalFailed = _.DetailResult.ViolationRatio.FailedChecks,
Grade = _.DetailResult.Grade
})
.Distinct(new RuleViolationResultDTO.Comparer())
.OrderByDescending(_ => _.TotalFailed)
.Take(nbTopResult)
.ToList());
}
protected override TableDefinition Content(ReportData reportData, Dictionary <string, string> options)
{
var results = RulesViolationUtility.GetStatViolation(reportData.CurrentSnapshot);
int param = 0;
bool showPrevious = false;
if (reportData.PreviousSnapshot != null && null != options && options.ContainsKey("SHOW_PREVIOUS") && Int32.TryParse(options["SHOW_PREVIOUS"], out param))
{
showPrevious = (param != 0);
}
List <string> rowData = new List <string>();
int nbRows = 0;
rowData.AddRange(new[] {
" ",
Labels.TQI,
Labels.Robu,
Labels.Efcy,
Labels.Secu,
Labels.Trans,
Labels.Chang
});
nbRows++;
var busCrit = new Constants.BusinessCriteria[] {
Constants.BusinessCriteria.TechnicalQualityIndex,
Constants.BusinessCriteria.Robustness,
Constants.BusinessCriteria.Performance,
Constants.BusinessCriteria.Security,
Constants.BusinessCriteria.Transferability,
Constants.BusinessCriteria.Changeability
};
var curVersion = new int[busCrit.Length];
var added = new int[busCrit.Length];
var removed = new int[busCrit.Length];
foreach (var resultModule in results)
{
if (resultModule != null)
{
for (int i = 0; i < busCrit.Length; i++)
{
var crit = busCrit[i];
if (resultModule[crit] != null)
{
if (resultModule[crit].Total.HasValue)
{
curVersion[i] += resultModule[crit].Total.Value;
}
if (resultModule[crit].Added.HasValue)
{
added[i] += resultModule[crit].Added.Value;
}
if (resultModule[crit].Removed.HasValue)
{
removed[i] += resultModule[crit].Removed.Value;
}
}
}
}
}
rowData.Add(Labels.VersionCurrent);
foreach (var curValue in curVersion)
{
rowData.Add(curValue.ToString());
}
nbRows++;
rowData.Add(" " + Labels.ViolationsAdded);
foreach (var addValue in added)
{
rowData.Add(TableBlock.FormatEvolution(addValue));
}
nbRows++;
rowData.Add(" " + Labels.ViolationsRemoved);
foreach (var remValue in removed)
{
rowData.Add(TableBlock.FormatEvolution(-remValue));
}
nbRows++;
if (showPrevious)
{
var prevVersion = new int[busCrit.Length];
results = RulesViolationUtility.GetStatViolation(reportData.PreviousSnapshot);
foreach (var resultModule in results)
{
if (resultModule != null)
{
for (int i = 0; i < busCrit.Length; i++)
{
var crit = busCrit[i];
if (resultModule[crit] != null && resultModule[crit].Total.HasValue)
{
prevVersion[i] += resultModule[crit].Total.Value;
}
}
}
}
rowData.Add(Labels.VersionPrevious);
foreach (var prevValue in prevVersion)
{
rowData.Add(prevValue.ToString());
}
nbRows++;
}
var resultTable = new TableDefinition {
HasRowHeaders = false,
HasColumnHeaders = true,
NbRows = nbRows,
NbColumns = busCrit.Length + 1,
Data = rowData
};
return(resultTable);
}
/// <summary>
///
/// </summary>
/// <param name="snapshot"></param>
/// <param name="moduleHRef"></param>
/// <param name="bcId"></param>
/// <returns></returns>
public static Double?GetBusinessCriteriaModuleGrade(Snapshot snapshot, Int32 moduleId, Constants.BusinessCriteria bcId, bool Round)
{
double?res = null;
if (null != snapshot && null != snapshot.BusinessCriteriaResults)
{
double?result = null;
result = snapshot.BusinessCriteriaResults
.Where(_ => _.Reference.Key == (Int32)bcId && _.ModulesResult != null)
.SelectMany(_ => _.ModulesResult)
.Where(_ => _.Module.Id == moduleId && _.DetailResult != null)
.Select(_ => _.DetailResult.Grade)
.FirstOrDefault();
if (result != null)
{
res = Round ? MathUtility.GetRound(result) : result;
}
}
return(res);
}
/// <summary>
///
/// </summary>
/// <param name="snapshot"></param>
/// <param name="businessCriteriaId"></param>
/// <param name="count"></param>
/// <returns></returns>
public static List <TechnicalCriteriaResultDTO> GetTechnicalCriteriaViolations(Snapshot snapshot, Constants.BusinessCriteria businessCriteriaId, int count)
{
if (snapshot.QIBusinessCriterias == null || snapshot.TechnicalCriteriaResults == null)
{
return(null);
}
IEnumerable <int> technicalCriteriaId = snapshot.QIBusinessCriterias.Where(_ => (int)businessCriteriaId == _.Key)
.SelectMany(_ => _.Contributors).Select(_ => _.Key);
return(snapshot.TechnicalCriteriaResults.Where(_ => technicalCriteriaId.Contains(_.Reference.Key) && _.Reference != null && _.DetailResult != null && _.RulesViolation != null)
.Select(_ => new TechnicalCriteriaResultDTO
{
Name = _.Reference.Name,
Grade = _.DetailResult.Grade,
TotalChecks = _.RulesViolation.Sum(r => (r.DetailResult?.ViolationRatio != null) ? r.DetailResult.ViolationRatio.TotalChecks : 0),
TotalFailed = _.RulesViolation.Sum(r => (r.DetailResult?.ViolationRatio != null) ? r.DetailResult.ViolationRatio.FailedChecks : 0)
})
.OrderByDescending(_ => _.TotalFailed)
.Take(count)
.ToList());
}
/// <summary>
///
/// </summary>
/// <param name="snapshot"></param>
/// <param name="moduleHRef"></param>
/// <param name="bcId"></param>
/// <param name="round"></param>
/// <returns></returns>
public static double?GetBusinessCriteriaModuleGrade(Snapshot snapshot, string moduleHRef, Constants.BusinessCriteria bcId, bool round)
{
double?res = null;
if (snapshot?.BusinessCriteriaResults == null)
{
return(null);
}
double?result = snapshot.BusinessCriteriaResults
.Where(_ => _.Reference.Key == (int)bcId && _.ModulesResult != null)
.SelectMany(_ => _.ModulesResult)
.Where(_ => _.Module.Href == moduleHRef && _.DetailResult != null)
.Select(_ => _.DetailResult.Grade)
.FirstOrDefault();
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (result != null)
{
res = round ? MathUtility.GetRound(result) : result;
}
return(res);
}
