public ChildAreaValuesBuilder(IndicatorComparerFactory indicatorComparerFactory,
IGroupDataReader groupDataReader, IAreasReader areasReader, IProfileReader profileReader)
: base(groupDataReader)
{
this.indicatorComparerFactory = indicatorComparerFactory;
this.areasReader = areasReader;
this.profileReader = profileReader;
}
public HealthProfilesKeyMessageDataBuilder(IArea area, CoreDataSetProvider coreDataSetProvider,
CoreDataSetProvider benchmarkDataProvider, IndicatorMetadataCollection indicatorMetadataCollection,
HealthProfilesGroupRootSelector groupRootSelector)
{
_area = area;
keyMessageData.Area = area;
this.coreDataSetProvider = coreDataSetProvider;
this.benchmarkDataProvider = benchmarkDataProvider;
this.groupRootSelector = groupRootSelector;
this.indicatorMetadataCollection = indicatorMetadataCollection;
_indicatorComparerFactory = new IndicatorComparerFactory {PholioReader = pholioReader};
}
public void TestPolarityIsAssigned()
{
var polarityId = PolarityIds.RagHighIsGood;
var comparatorMethodId = ComparatorMethodId.DoubleOverlappingCIs;
var comparer = new IndicatorComparerFactory { PholioReader = MockPholioReader() }.New(
new Grouping
{
ComparatorMethodId = comparatorMethodId,
PolarityId = polarityId
});
Assert.AreEqual(polarityId, comparer.PolarityId);
}
private void InitBuilder(int childAreaTypeId)
{
builder = new GroupRootNationalValuesBuilder();
var indicatorComparer = new IndicatorComparerFactory
{
PholioReader = ReaderFactory.GetPholioReader()
};
var listBuilder = new ChildAreaValuesBuilder(indicatorComparer,
ReaderFactory.GetGroupDataReader(), ReaderFactory.GetAreasReader(),
ReaderFactory.GetProfileReader())
{
ParentAreaCode = AreaCodes.England,
AreaTypeId = childAreaTypeId
};
builder.ChildAreaValuesBuilder = listBuilder;
}
public IList<CoreDataSet> GetValues()
{
var profileId = GetProfileId();
var grouping = GetGrouping(profileId);
var indicatorComparerFactory = new IndicatorComparerFactory
{
PholioReader = ReaderFactory.GetPholioReader()
};
ChildAreaValuesBuilder builder = new ChildAreaValuesBuilder(indicatorComparerFactory, groupDataReader,
ReaderFactory.GetAreasReader(), profileReader)
{
AreaTypeId = _parameters.AreaTypeId,
ParentAreaCode = _parameters.ParentAreaCode,
DataPointOffset = _parameters.DataPointOffset,
ComparatorId = _parameters.ComparatorId,
RestrictToProfileId = GetProfileId()
};
return builder.Build(grouping);
}
public LongerLivesAreaDetails GetAreaDetails(int profileId, int groupId,
int childAreaTypeId, string areaCode)
{
area = AreaFactory.NewArea(areasReader, areaCode);
indicatorComparerFactory = new IndicatorComparerFactory
{
PholioReader = ReaderFactory.GetPholioReader()
};
var parentCodeToRanks = new Dictionary<string, List<AreaRankGrouping>>();
var parentCodeToSignificances = new Dictionary<string, List<int?>>();
var parentCodeToBenchmarks = new Dictionary<string, object>();
InitIgnoredAreaCodes(profileId);
// Set up parent areas
Area country = areasReader.GetAreaFromCode(AreaCodes.England);
var parentAreas = new List<IArea> { country };
AddOnsClusterToParentAreas(childAreaTypeId, area, parentAreas);
Decile decile = GetDecile(parentAreas, childAreaTypeId, areaCode);
var isParentArea = IsParentArea(area);
foreach (IArea parentArea in parentAreas)
{
string parentAreaCode = parentArea.Code;
GroupData groupData = new GroupDataAtDataPointRepository().GetGroupDataProcessed(
parentAreaCode, childAreaTypeId, profileId, groupId);
var rankBuilder = new AreaRankBuilder
{
GroupDataReader = groupDataReader,
AreasReader = areasReader,
Area = area
};
var ranks = new List<AreaRankGrouping>();
var significances = new List<int?>();
var benchmarks = new List<CoreDataSet>();
parentCodeToRanks.Add(parentAreaCode, ranks);
foreach (GroupRoot groupRoot in groupData.GroupRoots)
{
Grouping grouping = GetGrouping(parentArea, groupRoot);
// Get data list
IndicatorMetadata metadata = groupData.GetIndicatorMetadataById(grouping.IndicatorId);
TimePeriod timePeriod = TimePeriod.GetDataPoint(grouping);
IList<CoreDataSet> childAreaDataList =
GetChildAreaDataList(parentArea, groupRoot, grouping, timePeriod);
var areaRankGrouping = rankBuilder.BuildRank(grouping, metadata, timePeriod, childAreaDataList);
ranks.Add(areaRankGrouping);
// Area significance
if (areaRankGrouping != null && isParentArea == false)
{
var significance = GetSignificance(areaCode, groupRoot, grouping, childAreaDataList);
significances.Add(significance);
}
else
{
significances.Add(null);
}
benchmarks.Add(grouping.ComparatorData);
}
parentCodeToSignificances.Add(parentAreaCode, significances);
parentCodeToBenchmarks.Add(parentAreaCode, benchmarks);
}
string url = null;
if (isParentArea)
{
// Significances not relevant for parent areas
parentCodeToSignificances = null;
parentCodeToBenchmarks = null;
}
else
{
// Only need area web site link for child areas
url = areasReader.GetAreaUrl(area.Code);
}
// Bespoke response object
return new LongerLivesAreaDetails
{
Area = area,
Decile = decile,
Url = url,
Ranks = parentCodeToRanks,
Significances = parentCodeToSignificances,
Benchmarks = parentCodeToBenchmarks
};
}
public Dictionary<string, IList<SimpleAreaData>> Build()
{
IndicatorMetadataRepository indicatorMetadataRepository = IndicatorMetadataRepository.Instance;
IList<Grouping> groupings = groupDataReader.GetGroupingsByGroupIdAndAreaTypeIdOrderedBySequence(GroupId, AreaTypeId);
GroupRootBuilder rootBuilder = new GroupRootBuilder();
IList<GroupRoot> roots = rootBuilder.BuildGroupRoots(groupings);
CoreDataSetProviderFactory coreDataSetProviderFactory = new CoreDataSetProviderFactory();
Dictionary<string, IList<SimpleAreaData>> responseObjects = new Dictionary<string, IList<SimpleAreaData>>();
foreach (IArea area in Areas)
{
List<SimpleAreaData> dataObjects = new List<SimpleAreaData>();
responseObjects.Add(area.Code, dataObjects);
var isAreaCcg = area.IsCcg;
bool isAreaAggregate = isAreaCcg || area.IsGpDeprivationDecile || area.IsShape;
CoreDataSetProvider coreDataSetProvider = coreDataSetProviderFactory.New(area);
var indicatorComparerFactory =
new IndicatorComparerFactory { PholioReader = pholioReader };
foreach (GroupRoot root in roots)
{
Grouping grouping = root.FirstGrouping;
IndicatorComparer comparer = indicatorComparerFactory.New(grouping);
IndicatorMetadata metadata = indicatorMetadataRepository.GetIndicatorMetadata(grouping.IndicatorId);
var formatter = NumericFormatterFactory.New(metadata, groupDataReader);
var dataProcessor = new ValueWithCIsDataProcessor(formatter);
List<ValueData> dataList = new List<ValueData>();
ITimePeriodTextListBuilder timePeriodTextListBuilder =
TimePeriodTextListBuilderFactory.New(IncludeTimePeriods, metadata);
Dictionary<string, List<int?>> significanceHash = null;
if (isAreaAggregate == false || isAreaCcg)
{
significanceHash = GetSignificanceHash(ComparatorAreaCodes);
}
var timePeriods = GetTimePeriods(grouping, metadata.YearType);
foreach (TimePeriod timePeriod in timePeriods)
{
timePeriodTextListBuilder.Add(timePeriod);
CoreDataSet areaData = coreDataSetProvider.GetData(grouping, timePeriod, metadata);
if (areaData != null)
{
ValueWithCIsData data = areaData.GetValueWithCIsData();
dataProcessor.FormatAndTruncate(data);
if (isAreaAggregate && isAreaCcg == false)
{
dataList.Add(data.GetValueData());
}
else
{
dataList.Add(data);
foreach (var comparatorAreaCode in ComparatorAreaCodes)
{
CoreDataSet comparatorData =
groupDataReader.GetCoreData(grouping, timePeriod, comparatorAreaCode)
.FirstOrDefault();
try
{
int significance;
if (comparer is ICategoryComparer)
{
var d = new ChildAreaValuesBuilder(indicatorComparerFactory,
groupDataReader, areasReader, profileReader)
{
ParentAreaCode = comparatorAreaCode,
AreaTypeId = AreaTypeId,
ComparatorId = grouping.ComparatorId
}.Build(grouping);
var coreData = d.First(x => x.AreaCode.Equals(area.Code));
significance = coreData.Significance.Values.First();
}
else
{
significance =
(int)comparer.Compare(areaData, comparatorData, metadata);
}
var significanceList = significanceHash[comparatorAreaCode];
significanceList.Add(significance);
}
catch (Exception ex)
{
ExceptionLog.LogException(ex, string.Empty);
}
}
}
}
else
{
// Placeholders for missing data
dataList.Add(null);
if (significanceHash != null)
{
foreach (var comparatorAreaCode in ComparatorAreaCodes)
{
significanceHash[comparatorAreaCode].Add(null);
}
}
}
}
SimpleAreaData dataObject;
if (IncludeTimePeriods)
{
// Only attach metadata when requested (hybrid of GroupRoot & CoreDataSet)
//TODO this is difficult to keep aligned with Grouping class
dataObject = new FullAreaData
{
IndicatorId = grouping.IndicatorId,
Significances = significanceHash,
Data = dataList,
StateSex = root.StateSex,
Sex = grouping.Sex,
Age = grouping.Age,
ComparatorConfidence = grouping.ComparatorConfidence,
ComparatorMethodId = grouping.ComparatorMethodId,
Periods = timePeriodTextListBuilder.GetTimePeriodStrings()
};
}
else
{
dataObject = new SimpleAreaData
{
IndicatorId = grouping.IndicatorId,
Significances = significanceHash,
Data = dataList
};
}
dataObjects.Add(dataObject);
}
}
return responseObjects;
}
