public IList<TrendRoot> GetTrendData()
        {
            int profileId = _parameters.ProfileId;

            var parentArea = new ParentArea(_parameters.ParentAreaCode, _parameters.AreaTypeId);
            ComparatorMap comparatorMap = new ComparatorMapBuilder(parentArea).ComparatorMap;

            // Do not repository as do not want results cached like this (need to be
            // cached by ID and areatype, i.e. repository by roots)
            GroupData data = new GroupDataBuilderByIndicatorIds
            {
                IndicatorIds = _parameters.IndicatorIds,
                ComparatorMap = comparatorMap,
                AreaTypeId = _parameters.AreaTypeId,
                RestrictSearchProfileIds = _parameters.RestrictResultsToProfileIdList,
                ProfileId = profileId
            }.Build();

            if (data.IsDataOk)
            {
                var groupDataReader = ReaderFactory.GetGroupDataReader();
                data.GroupRoots = new GroupRootFilter(groupDataReader).RemoveRootsWithoutChildAreaData(data.GroupRoots);
            }

            bool isParentAreaCodeNearestNeighbour = Area.IsNearestNeighbour(_parameters.ParentAreaCode);

            IList<TrendRoot> trendRoots = new TrendRootBuilder().Build(data.GroupRoots, comparatorMap,
                _parameters.AreaTypeId, profileId, data.IndicatorMetadata, isParentAreaCodeNearestNeighbour);

            return trendRoots;
        }
        public void TestBuild()
        {
            var areaTypeId = AreaTypeIds.CountyAndUnitaryAuthority;
            var profileId = ProfileIds.Phof;
            var profile = ReaderFactory.GetProfileReader().GetProfile(profileId);

            var parentArea = new ParentArea(AreaCodes.Gor_NorthEast, areaTypeId);
            ComparatorMap comparatorMap = new ComparatorMapBuilder(parentArea).ComparatorMap;

            GroupData data = new GroupDataBuilderByGroupings
            {
                GroupId = profile.GroupIds[0],
                ChildAreaTypeId = areaTypeId,
                ProfileId = profile.Id,
                ComparatorMap = comparatorMap,
                AssignData = true
            }.Build();

            IList<TrendRoot> trendRoots = new TrendRootBuilder().Build(data.GroupRoots, comparatorMap, areaTypeId, profileId,
                data.IndicatorMetadata, false);
            Assert.IsTrue(trendRoots.Count > 0);
            Assert.IsTrue(trendRoots[0].Periods.Count > 0);
            Assert.IsNotNull(trendRoots[0].Limits);
            Assert.IsTrue(trendRoots[0].ComparatorValueFs.Count > 0);

            string s = trendRoots[0].ComparatorValueFs[0][ComparatorIds.Subnational];
            Assert.AreNotEqual("-", s);
        }
        public IList<TrendRoot> GetTrendData()
        {
            var parentArea = new ParentArea(_parameters.ParentAreaCode, _parameters.AreaTypeId);

            bool isParentCodeNearestNeighbour = Area.IsNearestNeighbour(_parameters.ParentAreaCode);

            var groupData = new GroupDataAtDataPointRepository().GetGroupData(_parameters.ParentAreaCode,
                _parameters.AreaTypeId, _parameters.ProfileId, _parameters.GroupId);

            IList<TrendRoot> trendRoots = new TrendRootBuilder().Build(
               groupData.GroupRoots,
                new ComparatorMapBuilder(parentArea).ComparatorMap,
                _parameters.AreaTypeId,
                _parameters.ProfileId,
                groupData.IndicatorMetadata, isParentCodeNearestNeighbour);

            return trendRoots;
        }
        public void Build_Returns_Results_With_Trends()
        {
            var comparatorMap = GetComparatorMap(ComparatorMapBuilderTest.GetRegion102());

            var data = new GroupDataBuilderByGroupings
            {
                GroupId = GroupIds.Phof_WiderDeterminantsOfHealth,
                ProfileId = ProfileIds.Phof,
                ComparatorMap = comparatorMap,
                ChildAreaTypeId = AreaTypeIds.CountyAndUnitaryAuthority
            }.Build();

            var trendRoots = new TrendRootBuilder().Build(data.GroupRoots, comparatorMap,
                AreaTypeIds.CountyAndUnitaryAuthority, ProfileIds.Phof,
               data.IndicatorMetadata, false);

            var trendRoot = trendRoots.FirstOrDefault();
            Assert.IsTrue(trendRoots.Any()
                && trendRoot != null
                && trendRoot.RecentTrends != null
                && trendRoot.RecentTrends.Count > 0
                );
        }
        public void TestDiabetesPrevAndRiskHighestQuintileExists()
        {
            var areaTypeId = AreaTypeIds.Ccg;
            var profileId = ProfileIds.Diabetes;

            var parentArea = new ParentArea(AreaCodes.CommissioningRegionLondon, areaTypeId);
            ComparatorMap comparatorMap = new ComparatorMapBuilder(parentArea).ComparatorMap;

            GroupData data = new GroupDataBuilderByGroupings
            {
                GroupId = GroupIds.Diabetes_PrevalenceAndRisk,
                ChildAreaTypeId = areaTypeId,
                ProfileId = ProfileIds.Diabetes,
                ComparatorMap = comparatorMap,
                AssignData = true
            }.Build();

            IList<TrendRoot> trendRoots = new TrendRootBuilder().Build(data.GroupRoots, comparatorMap, areaTypeId, profileId,
                data.IndicatorMetadata, false);

            var highestQuintileCount = trendRoots.Select(x => x.DataPoints.Values.FirstOrDefault()[0].Significance).Count(significances => significances.ContainsValue((Significance)5));

            Assert.AreNotEqual(highestQuintileCount, 0);
        }