public void TestFilterCoreDataSet()
{
var codes = new[] { "a", "b" };
var filteredData = new CoreDataSetFilter(TestData()).RemoveWithAreaCode(codes);
Assert.AreEqual(1, filteredData.Count());
Assert.AreEqual("c", filteredData.First().AreaCode);
}
private static IEnumerable<CkanCoreDataSet> FilterAndConvert(IList<string> areaCodesToIgnore,
IList<CoreDataSet> dataList, string periodString)
{
dataList = new CoreDataSetFilter(dataList)
.RemoveWithAreaCode(areaCodesToIgnore).ToList();
var ckanDataList = dataList
.Select(x => new CkanCoreDataSet(x, periodString));
return ckanDataList;
}
public Limits GetLimits(IList<CoreDataSet> dataList)
{
if (dataList == null || dataList.Any() == false)
{
return null;
}
var values = new CoreDataSetFilter(dataList).SelectValidValues().ToList();
if (values.Any() == false)
{
return null;
}
return GetLimitsFromMinAndMax(values.Min(), values.Max());
}
public void TestFilterCoreDataSetCaseInsensitive()
{
// WRT ignored codes
var filteredData = new CoreDataSetFilter(TestData()).RemoveWithAreaCode(new[] { "A", "B" });
Assert.AreEqual(1, filteredData.Count());
Assert.AreEqual("c", filteredData.First().AreaCode);
// WRT coredataset area codes
var data = TestData();
foreach (var coreDataSet in data)
{
coreDataSet.AreaCode = coreDataSet.AreaCode.ToUpper();
}
filteredData = new CoreDataSetFilter(data).RemoveWithAreaCode(new[] { "a", "b" });
Assert.AreEqual(1, filteredData.Count());
Assert.AreEqual("C", filteredData.First().AreaCode);
}
public CcgAverageCalculator(IList<CoreDataSet> dataList, CcgPopulation ccgPopulation, IndicatorMetadata indicatorMetadata)
{
Unit unit = indicatorMetadata.Unit;
if (indicatorMetadata.ValueTypeId == ValueTypeId.Ratio)
{
return;
}
if (dataList.Any(x => x.IsCountValid && x.IsDenominatorValid))
{
var validData = new CoreDataSetFilter(dataList).SelectWhereCountAndDenominatorAreValid().ToList();
if (RuleAreEnoughPracticeValuesByPopulation.Validates(validData, ccgPopulation))
{
Average = WeightedAverageCalculator.CalculateAverage(validData, unit);
Average.AreaCode = ccgPopulation.AreaCode;
}
}
else if (dataList.Any(x => x.IsValueValid))
{
var practiceCodeToPopulationMap = ccgPopulation.PracticeCodeToPopulation;
// Keep only data where population is available
var dataWithPopulation = dataList.Where(x => practiceCodeToPopulationMap.ContainsKey(x.AreaCode)).ToList();
if (RuleAreEnoughPracticeValuesByPopulation.Validates(dataWithPopulation, ccgPopulation))
{
Average = CoreDataSet.GetNullObject(ccgPopulation.AreaCode);
// Population weighted average
Average.Value = dataWithPopulation.Sum(data => (data.Value * practiceCodeToPopulationMap[data.AreaCode])) /
ccgPopulation.TotalPopulation;
}
}
}
private IList<CoreDataSet> GetChildAreaDataList(IArea parentArea,
GroupRoot groupRoot, Grouping grouping, TimePeriod timePeriod)
{
IList<CoreDataSet> dataList;
if (parentArea.IsCountry)
{
if (area.IsGpPractice)
{
// No need to calculate rank of practice in whole country
throw new FingertipsException("Do not use for GP Practices");
}
else
{
// All data in country
dataList = new CoreDataSetListProvider(groupDataReader).GetChildAreaData(grouping,
parentArea, timePeriod);
dataList = new CoreDataSetFilter(dataList).RemoveWithAreaCode(ignoredAreaCodes).ToList();
}
}
else
{
// Use subnational data
dataList = groupRoot.Data;
}
return dataList;
}
private int GetSignificance(string areaCode, GroupRoot groupRoot, Grouping grouping,
IList<CoreDataSet> childAreaDataList)
{
CoreDataSet areaData = AreaHelper.GetDataForAreaFromDataList(areaCode, groupRoot.Data);
if (areaData == null)
{
return (int)Significance.None;
}
var comparer = indicatorComparerFactory.New(grouping);
if (comparer is ICategoryComparer)
{
ICategoryComparer categoryComparer = comparer as ICategoryComparer;
var values = new CoreDataSetFilter(childAreaDataList).SelectValidValues().ToList();
categoryComparer.SetDataForCategories(values);
return categoryComparer.GetCategory(areaData);
}
return areaData.Significance[grouping.ComparatorId];
}
public void TestSelectDistinctAgeIds()
{
var data = new[] {
new CoreDataSet{AgeId = 2},
new CoreDataSet{AgeId = 2}
};
var ids = new CoreDataSetFilter(data).SelectDistinctAgeIds();
// Check IDs
Assert.AreEqual(1, ids.Count());
Assert.AreEqual(2, ids.First());
}
public void TestRemoveWithAreaCode_NullListInConstructor()
{
var filteredData = new CoreDataSetFilter(null).RemoveWithAreaCode(new List<string>());
Assert.AreEqual(0, filteredData.Count());
}
public void TestSelectWhereCountAndDenominatorAreValid()
{
var data = new[] {
new CoreDataSet{Count = 1,Denominator = 2},
new CoreDataSet{Count = 1,Denominator = 2}
};
var filteredData = new CoreDataSetFilter(data).SelectWhereCountAndDenominatorAreValid();
Assert.AreEqual(2, filteredData.Count());
}
private IList<Sex> GetSexesFromDataList(IList<CoreDataSet> dataList)
{
List<int> sexIds = new CoreDataSetFilter(dataList).SelectDistinctSexIds().ToList();
IList<Sex> sexes = _pholioReader.GetSexesByIds(sexIds);
return sexes;
}
private CoreDataSet GetFormattedValueData(TimePeriod period, IList<CoreDataSet> coreDataSetList, Grouping grouping,
IEnumerable<string> childAreaCodes)
{
CoreDataSet benchmarkData = GetDataAtSpecificTimePeriod(coreDataSetList, period);
var parentArea = new Area { Code = coreDataSetList.Select(x => x.AreaCode).FirstOrDefault() };
if (benchmarkData == null && grouping != null)
{
//Get child area data only when necessary
var childAreaData = new CoreDataSetListProvider(groupDataReader).GetChildAreaData(grouping, parentArea, period);
var filteredChildAreaData = new CoreDataSetFilter(childAreaData).SelectWithAreaCode(childAreaCodes);
benchmarkData = AverageCalculatorFactory.New(filteredChildAreaData, IndicatorMetadata).Average;
}
if (benchmarkData == null)
{
benchmarkData = CoreDataSet.GetNullObject(parentArea.Code);
}
dataProcessor.FormatAndTruncate(benchmarkData);
return benchmarkData;
}
private ICategoryComparer GetCategoryComparerWithValues(Dictionary<TimePeriod, ICategoryComparer> periodToComparer,
CoreDataSetListProvider provider, Grouping grouping, TimePeriod period, string areaCode)
{
if (periodToComparer.ContainsKey(period) == false)
{
Area area = areasReader.GetAreaFromCode(areaCode);
var childDataList = provider.GetChildAreaData(grouping, area, period);
var comparatorValues = new CoreDataSetFilter(childDataList).SelectValidValues().ToList();
// Get comparer
var categoryComparer = (ICategoryComparer)NewIndicatorComparer();
categoryComparer.SetDataForCategories(comparatorValues);
periodToComparer[period] = categoryComparer;
// Truncate last
dataProcessor.FormatAndTruncateList(childDataList);
}
return periodToComparer[period];
}
public void TestSelectWithAreaCode()
{
var codes = new[] { "a", "b" };
var filteredData = new CoreDataSetFilter(TestData()).SelectWithAreaCode(codes);
Assert.AreEqual(2, filteredData.Count());
Assert.IsNotNull(filteredData.First(x => x.AreaCode == "a"));
Assert.IsNotNull(filteredData.First(x => x.AreaCode == "b"));
}
public void TestSelectWhereValueIsValid_InvalidValueRemoved()
{
var validValue = 1;
var data = new[] {
new CoreDataSet{Value = validValue},
new CoreDataSet{Value = ValueData.NullValue}
};
var filteredData = new CoreDataSetFilter(data).SelectWhereValueIsValid();
Assert.AreEqual(1, filteredData.Count());
Assert.AreEqual(validValue, filteredData.First().Value);
}
public void TestSelectWhereValueIsValid()
{
var data = new[] {
new CoreDataSet{Value = 1},
new CoreDataSet{Value = 1}
};
var filteredData = new CoreDataSetFilter(data).SelectWhereValueIsValid();
Assert.AreEqual(2, filteredData.Count());
}
public void TestSelectWhereCountIsValid_InvalidCountRemoved()
{
var data = new[] {
new CoreDataSet{Count = null},
new CoreDataSet{Count = -1},
new CoreDataSet{Count = 1}
};
var filteredData = new CoreDataSetFilter(data).SelectWhereCountIsValid();
Assert.AreEqual(1, filteredData.Count());
Assert.AreEqual(1, filteredData.First().Count);
}
public void TestSelectWhereCountAndDenominatorAreValid_InvalidDenominatorRemoved()
{
var data = new[] {
new CoreDataSet{Count = 1,Denominator = -1},
new CoreDataSet{Count = 1, Denominator = 2},
};
var filteredData = new CoreDataSetFilter(data).SelectWhereCountAndDenominatorAreValid();
Assert.AreEqual(1, filteredData.Count());
Assert.AreEqual(2, filteredData.First().Denominator);
}
private IList<Age> GetAgesFromDataList(IList<CoreDataSet> dataList)
{
var ageIds = new CoreDataSetFilter(dataList).SelectDistinctAgeIds().ToList();
var ages = _pholioReader.GetAgesByIds(ageIds);
ages = new AgeSorter().SortByAge(ages);
return ages;
}
public CountAverageCalculator(CoreDataSetFilter coreDataSetFilter)
{
this.coreDataSetFilter = coreDataSetFilter;
}
public void TestRemoveWithAreaCodeIgnoresEmptyListOfAreaCodes()
{
var filteredData = new CoreDataSetFilter(TestData()).RemoveWithAreaCode(new string[] { });
Assert.AreEqual(3, filteredData.Count());
}
public WeightedAverageCalculator(CoreDataSetFilter coreDataSetFilter, Unit unit)
{
this.coreDataSetFilter = coreDataSetFilter;
this.unit = unit;
}
public void TestRemoveWithAreaCodeIgnoresNullListOfAreaCodes()
{
var filteredData = new CoreDataSetFilter(TestData()).RemoveWithAreaCode(null);
Assert.AreEqual(3, filteredData.Count());
}
private IEnumerable<double> GetValuesForStats(Grouping grouping, TimePeriod timePeriod)
{
IList<CoreDataSet> data = null;
IList<double> values;
if (parentArea.IsCountry)
{
// Optimisation for large number of areas
values = groupDataReader.GetOrderedCoreDataValidValuesForAllAreasOfType(grouping, timePeriod,
areaCodesToIgnore);
}
else
{
data = new CoreDataSetListProvider(groupDataReader).GetChildAreaData(grouping, parentArea, timePeriod);
data = new CoreDataSetFilter(data).RemoveWithAreaCode(areaCodesToIgnore).ToList();
data = data.OrderBy(x => x.Value).ToList();
values = new ValueListBuilder(data).ValidValues;
}
// Apply rules
int areaTypeId = grouping.AreaTypeId;
if (areaTypeId != AreaTypeIds.GpPractice)
{
doEnoughAreasHaveValues = IsRequiredNumberOfAreaValues(values) ||
ShouldSpineChartAlwaysBeAvailable(grouping.IndicatorId);
if (doEnoughAreasHaveValues == false)
{
values = null;
}
}
else if (parentArea.IsCcg)
{
// CCG average of GP practices
if (RuleShouldCcgAverageBeCalculated.Validates(grouping, data, ccgPopulation) == false)
{
values = null;
}
}
return values;
}
private void PerformComparisons(IList<CoreDataSet> dataList)
{
IndicatorComparer comparer = indicatorComparerFactory.New(Grouping);
TargetComparer targetComparer = TargetComparerFactory.New(IndicatorMetadata.TargetConfig);
new TargetComparerHelper(groupDataReader, parentArea)
.AssignExtraDataIfRequired(parentArea, targetComparer, Grouping, IndicatorMetadata);
CoreDataSet benchmarkData = null;
ICategoryComparer categoryComparer = null;
var averageCalculator = AverageCalculatorFactory.New(dataList, IndicatorMetadata);
if (comparer is ICategoryComparer)
{
categoryComparer = comparer as ICategoryComparer;
var values = new CoreDataSetFilter(dataList).SelectValidValues().ToList();
categoryComparer.SetDataForCategories(values);
}
else
{
benchmarkData = new BenchmarkDataProvider(groupDataReader)
.GetBenchmarkData(Grouping, Period, averageCalculator, parentArea);
}
foreach (CoreDataSet coreData in dataList)
{
// NHibernate may have provided a cached data object for which significance
// has already been added
if (coreData.Significance.ContainsKey(ComparatorId) == false)
{
int significance = categoryComparer == null
? (int)comparer.Compare(coreData, benchmarkData, IndicatorMetadata)
: categoryComparer.GetCategory(coreData);
coreData.Significance.Add(ComparatorId, significance);
}
// NHibernate may have provided a cached data object for which significance
// has already been added
if (coreData.Significance.ContainsKey(ComparatorIds.Target) == false)
{
TargetComparer.AddTargetSignificance(coreData, targetComparer);
}
}
}
