public static IArea NewArea(IAreasReader areasReader, string areaCode)
        {
            if (areaCode == null)
            {
                throw new FingertipsException("Area code was null");
            }

            // Category areas
            if (CategoryArea.IsCategoryAreaCode(areaCode))
            {
                var categoryArea = new CategoryArea(areaCode);
                var category = areasReader.GetCategory(categoryArea.CategoryTypeId, categoryArea.CategoryId);
                categoryArea.SetNames(category);
                return categoryArea;
            }

            // Nearest neighbour
            if (NearestNeighbourArea.IsNearestNeighbourAreaCode(areaCode))
            {
                var nearestNeighboursArea = new NearestNeighbourArea(areaCode);
                nearestNeighboursArea.Neighbours = areasReader.GetNearestNeighbours(
                    nearestNeighboursArea.AreaCodeOfAreaWithNeighbours, nearestNeighboursArea.NeighbourTypeId);
                return nearestNeighboursArea;
            }

            // Standard area
            return areasReader.GetAreaFromCode(areaCode);
        }
        public ChildAreaListBuilder(IAreasReader areasReader, string parentAreaCode, int childAreaTypeId)
        {
            IArea area = AreaFactory.NewArea(areasReader, parentAreaCode);

            var categoryArea = area as CategoryArea;
            if (categoryArea != null)
            {
                ChildAreas =
                    new ChildAreaListForCategoryAreaBuilder(areasReader, categoryArea, childAreaTypeId)
                    .ChildAreas
                    .ToList();
            }
            else if (Area.IsNearestNeighbour(parentAreaCode))
            {
                // TODO: this should be replaced by CreateAreaListFromNearestNeighbourAreaCode

                var nearestNeighbourArea = new NearestNeighbourArea(parentAreaCode);
                var nearestNeighbours = areasReader.GetNearestNeighbours(nearestNeighbourArea.AreaCodeOfAreaWithNeighbours, nearestNeighbourArea.NeighbourTypeId);
                var nearestNeighboursAreas = nearestNeighbours.Select(x => x.NeighbourAreaCode).ToList();
                var areas = areasReader.GetAreasFromCodes(nearestNeighboursAreas);
                ChildAreas = areas.Cast<IArea>().ToList();
            }
            else
            {
                var areas = area.IsCountry
                    ? areasReader.GetAreasByAreaTypeId(childAreaTypeId)
                    : areasReader.GetChildAreas(parentAreaCode, childAreaTypeId);

                ChildAreas = areas.Cast<IArea>().ToList();
            }
        }
        public void TestNeighbourAreaCodes()
        {
            var code = NearestNeighbourArea.CreateAreaCode(1, "a");
            var area = new NearestNeighbourArea(code);
            area.Neighbours = new []
            {
                new AreaCodeNeighbourMapping{NeighbourAreaCode = "b"},
                new AreaCodeNeighbourMapping{NeighbourAreaCode = "c"}
            };

            Assert.AreEqual(2, area.Neighbours.Count);
            Assert.AreEqual(2, area.NeighbourAreaCodes.Count);
            Assert.AreEqual("b", area.NeighbourAreaCodes[0]);
            Assert.AreEqual("c", area.NeighbourAreaCodes[1]);
        }
        public void TestAreas()
        {
            var code = NearestNeighbourArea.CreateAreaCode(1, "a");
            var area = new NearestNeighbourArea(code);
            area.Neighbours = new []
            {
                new AreaCodeNeighbourMapping{ NeighbourAreaCode = AreaCodes.CountyUa_Cambridgeshire},
                new AreaCodeNeighbourMapping{ NeighbourAreaCode = AreaCodes.CountyUa_Cumbria}
            };

            var areas = new NearestNeighbourAreaListBuilder(ReaderFactory.GetAreasReader(),
                area).Areas;

            Assert.AreEqual(2, areas.Count);
        }
 public void CreateAreaListFromNearestNeighbourAreaCode(int profileId, string parentAreaCode)
 {
     var nearestNeighbourArea = new NearestNeighbourArea(parentAreaCode);
     var nearestNeighbours = areasReader.GetNearestNeighbours(nearestNeighbourArea.AreaCodeOfAreaWithNeighbours, nearestNeighbourArea.NeighbourTypeId);
     var nearestNeighboursAreas = nearestNeighbours.Select(x => x.NeighbourAreaCode).ToList();
     var areas = areasReader.GetAreasFromCodes(nearestNeighboursAreas);
     var sortedAreas = new List<IArea>();
     // Sort list of NN by their rank.
     foreach (var nearestNeighbourAreaCode in nearestNeighboursAreas)
     {
         var temp = areas.Where(x => x.Code == nearestNeighbourAreaCode).FirstOrDefault();
         sortedAreas.Add(temp);
     }
     Areas = sortedAreas;
 }
        public NearestNeighbourAreaListBuilder(IAreasReader areasReader, NearestNeighbourArea nearestNeighbourArea)
        {
            var areaCodes = nearestNeighbourArea.NeighbourAreaCodes;

            IList<string> newAreaCodes = new List<string>();

            // add the selected area to the list of neighbours 
            // it should always be on zeroth index
            newAreaCodes.Add(nearestNeighbourArea.AreaCodeOfAreaWithNeighbours);

            foreach (var areaCode in areaCodes)
            {
                newAreaCodes.Add(areaCode);
            }

            var areas = areasReader.GetAreasFromCodes(newAreaCodes);
            Areas = areas.Cast<IArea>().ToList();
        }
        public void TestCreateAreaListFromNearestNeighbourAreaCode()
        {
            const string code = AreaCodes.NearestNeighbours_Derby;
            var nn = new NearestNeighbourArea(code);
            IAreasReader areasReader = ReaderFactory.GetAreasReader();

            var builder = new AreaListProvider(areasReader);
            builder.CreateAreaListFromNearestNeighbourAreaCode(
                ProfileIds.ChildrenAndYoungPeoplesBenchmarkingTool, code);

            // Check areas
            var areas = builder.Areas;
            Assert.IsNotNull(areas);

            // Check order of Nearest Neighbours
            var sortedNearestNeighboursByRank = areasReader.GetNearestNeighbours(nn.Code, 1);
            for (var i = 0; i < sortedNearestNeighboursByRank.Count; i++)
            {
                Assert.AreEqual(sortedNearestNeighboursByRank[i].NeighbourAreaCode, areas[i].Code);
            }
        }