public RightsOfWayDepositsViewModel BuildModel()
        {
            var model = new RightsOfWayDepositsViewModel();

            var searcher = ExamineManager.Instance.SearchProviderCollection["RightsOfWayDepositsSearcher"];
            var criteria = searcher.CreateSearchCriteria(IndexTypes.Content);

            criteria.NodeTypeAlias("RightsOfWayDeposit");
            criteria.ParentId(_umbracoParentNodeId);
            if (!String.IsNullOrEmpty(_searchTerm))
            {
                criteria.Field("RightsOfWayDepositSearch", _searchTerm);
            }

            if (_sortResults)
            {
                switch (_sortOrder)
                {
                case RightsOfWayDepositsSortOrder.ReferenceAscending:
                    criteria.OrderBy("nodeName");
                    break;

                case RightsOfWayDepositsSortOrder.ReferenceDescending:
                    criteria.OrderByDescending("nodeName");
                    break;

                case RightsOfWayDepositsSortOrder.ParishAscending:
                    criteria.OrderBy("Parish_Content");
                    break;

                case RightsOfWayDepositsSortOrder.ParishDescending:
                    criteria.OrderByDescending("Parish_Content");
                    break;

                case RightsOfWayDepositsSortOrder.DateDepositedAscending:
                    criteria.OrderBy("DateDeposited_Content");
                    break;

                case RightsOfWayDepositsSortOrder.DateExpiresAscending:
                    criteria.OrderBy("DateExpires_Content");
                    break;

                case RightsOfWayDepositsSortOrder.DateExpiresDescending:
                    criteria.OrderByDescending("DateExpires_Content");
                    break;

                default:
                    criteria.OrderByDescending("DateDeposited_Content");
                    break;
                }
            }

            var results = searcher.Search(criteria);

            model.TotalDeposits = results.Count();
            IEnumerable <SearchResult> selectedResults;

            if (_pageResults)
            {
                selectedResults = results.Skip((_currentPage - 1) * _pageSize).Take(_pageSize);
            }
            else
            {
                selectedResults = results;
            }

            foreach (var result in selectedResults)
            {
                var deposit = new RightsOfWayDepositViewModel();
                deposit.Reference = result.Fields["nodeName"];
                deposit.PageUrl   = new Uri(_baseUrl, result.Fields["urlName"]);

                if (result.Fields.Keys.Contains("DepositDocument_Content") && _umbracoHelper != null)
                {
                    var nodeIds          = result.Fields["DepositDocument_Content"].Split(',');
                    var multiMediaPicker = Enumerable.Empty <IPublishedContent>();
                    if (nodeIds.Length > 0)
                    {
                        multiMediaPicker = _umbracoHelper.TypedMedia(nodeIds).Where(x => x != null);
                    }

                    foreach (var media in multiMediaPicker)
                    {
                        deposit.DepositDocuments.Add(new HtmlLink()
                        {
                            Text = media.Name, Url = new Uri(_baseUrl, media.Url)
                        });
                    }
                }

                var nameConverter    = new PersonNamePropertyValueConverter();
                var addressConverter = new UkLocationPropertyValueConverter();
                for (var i = 1; i <= 5; i++)
                {
                    if (result.Fields.Keys.Contains($"Owner{i}_Content"))
                    {
                        var owner = nameConverter.ConvertDataToSource(null, result.Fields[$"Owner{i}_Content"], false) as PersonName;
                        if (owner != null)
                        {
                            deposit.IndividualOwners.Add(owner);
                        }
                    }

                    if (result.Fields.Keys.Contains($"OrganisationalOwner{i}_Content"))
                    {
                        var org = result.Fields[$"OrganisationalOwner{i}_Content"];
                        if (!String.IsNullOrEmpty(org))
                        {
                            deposit.OrganisationalOwners.Add(org);
                        }
                    }

                    if (result.Fields.Keys.Contains($"Location{((i > 1) ? i.ToString(CultureInfo.InvariantCulture) : String.Empty)}_Content"))
                    {
                        var addressInfo = addressConverter.ConvertDataToSource(null, result.Fields[$"Location{((i > 1) ? i.ToString(CultureInfo.InvariantCulture) : String.Empty)}_Content"], false) as AddressInfo;
                        if (addressInfo != null && addressInfo.BS7666Address.HasAddress() && addressInfo.BS7666Address.ToString() != addressInfo.BS7666Address.AdministrativeArea)
                        {
                            if (addressInfo.GeoCoordinate.Latitude == 0 && addressInfo.GeoCoordinate.Longitude == 0)
                            {
                                addressInfo.GeoCoordinate = null;
                            }
                            deposit.Addresses.Add(addressInfo);
                        }
                    }
                }

                if (result.Fields.Keys.Contains("Parish_Content"))
                {
                    var parishData = result.Fields["Parish_Content"];
                    if (!String.IsNullOrEmpty(parishData))
                    {
                        var parishes = parishData.Split(',');
                        foreach (var parish in parishes)
                        {
                            deposit.Parishes.Add(parish);
                        }
                    }
                }

                if (result.Fields.Keys.Contains("GridReference_Content"))
                {
                    deposit.OrdnanceSurveyGridReference = result.Fields["GridReference_Content"];
                }

                if (result.Fields.Keys.Contains("pageDescription_Content"))
                {
                    deposit.Description = result.Fields["pageDescription_Content"];
                }

                if (result.Fields.Keys.Contains("DateDeposited_Content"))
                {
                    deposit.DateDeposited = new DateTime(Int32.Parse(result.Fields["DateDeposited_Content"].Substring(0, 4)), Int32.Parse(result.Fields["DateDeposited_Content"].Substring(4, 2)), Int32.Parse(result.Fields["DateDeposited_Content"].Substring(6, 2)));
                }
                if (result.Fields.Keys.Contains("DateExpires_Content"))
                {
                    deposit.DateExpires = new DateTime(Int32.Parse(result.Fields["DateExpires_Content"].Substring(0, 4)), Int32.Parse(result.Fields["DateExpires_Content"].Substring(4, 2)), Int32.Parse(result.Fields["DateExpires_Content"].Substring(6, 2)));
                }
                model.Deposits.Add(deposit);
            }

            return(model);
        }
        public RightsOfWayModificationsViewModel BuildModel()
        {
            var model = new RightsOfWayModificationsViewModel();

            var criteria = _searcher.CreateSearchCriteria(IndexTypes.Content);

            criteria.NodeTypeAlias("RightsOfWayModification");
            criteria.ParentId(_umbracoParentNodeId);
            if (!String.IsNullOrEmpty(_searchTerm))
            {
                criteria.Field("RightsOfWayModificationSearch", _searchTerm);
            }
            if (!_includeCompleted)
            {
                criteria.Field("RightsOfWayModificationComplete", "false");
            }
            if (_sortResults)
            {
                switch (_sortOrder)
                {
                case RightsOfWayModificationsSortOrder.ReferenceAscending:
                    criteria.OrderBy("nodeName");
                    break;

                case RightsOfWayModificationsSortOrder.ReferenceDescending:
                    criteria.OrderByDescending("nodeName");
                    break;

                case RightsOfWayModificationsSortOrder.ParishAscending:
                    criteria.OrderBy("Parish");
                    break;

                case RightsOfWayModificationsSortOrder.ParishDescending:
                    criteria.OrderByDescending("Parish");
                    break;

                case RightsOfWayModificationsSortOrder.DateReceivedAscending:
                    criteria.OrderByDescending("DateReceived");
                    break;

                case RightsOfWayModificationsSortOrder.StatusAscending:
                    criteria.OrderBy("applicationStatus");
                    break;

                case RightsOfWayModificationsSortOrder.StatusDescending:
                    criteria.OrderByDescending("applicationStatus");
                    break;

                default:
                    criteria.OrderBy("DateReceived");
                    break;
                }
            }

            var results = _searcher.Search(criteria);

            model.TotalModificationOrderApplications = results.Count();
            IEnumerable <SearchResult> selectedResults;

            if (_pageResults)
            {
                selectedResults = results.Skip((_currentPage - 1) * _pageSize).Take(_pageSize);
            }
            else
            {
                selectedResults = results;
            }

            foreach (var result in selectedResults)
            {
                var application = new RightsOfWayModificationViewModel
                {
                    Reference = result.Fields["nodeName"],
                    PageUrl   = new Uri(_baseUrl, result.Fields["urlName"])
                };

                if (result.Fields.Keys.Contains("Documents") && _umbracoHelper != null)
                {
                    var nodeIds          = result.Fields["Documents"].Split(',');
                    var multiMediaPicker = Enumerable.Empty <IPublishedContent>();
                    if (nodeIds.Length > 0)
                    {
                        multiMediaPicker = _umbracoHelper.TypedMedia(nodeIds).Where(x => x != null);
                    }

                    foreach (var media in multiMediaPicker)
                    {
                        application.ApplicationDocuments.Add(new HtmlLink()
                        {
                            Text = media.Name, Url = new Uri(_baseUrl, media.Url)
                        });
                    }
                }

                var nameConverter    = new PersonNamePropertyValueConverter();
                var addressConverter = new UkLocationPropertyValueConverter();
                for (var i = 1; i <= 5; i++)
                {
                    if (result.Fields.Keys.Contains($"OrganisationalOwner{i}"))
                    {
                        var org = result.Fields[$"OrganisationalOwner{i}"];
                        if (!String.IsNullOrEmpty(org))
                        {
                            application.OrganisationalOwners.Add(org);
                        }
                    }

                    if (result.Fields.Keys.Contains($"Location{i}"))
                    {
                        var addressInfo = addressConverter.ConvertDataToSource(null, result.Fields[$"Location{i}"], false) as AddressInfo;
                        if (addressInfo != null && addressInfo.BS7666Address.HasAddress() && addressInfo.BS7666Address.ToString() != addressInfo.BS7666Address.AdministrativeArea)
                        {
                            if (addressInfo.GeoCoordinate.Latitude == 0 && addressInfo.GeoCoordinate.Longitude == 0)
                            {
                                addressInfo.GeoCoordinate = null;
                            }
                            application.Addresses.Add(addressInfo);
                        }
                    }
                }

                if (result.Fields.Keys.Contains("Parish"))
                {
                    var parishData = result.Fields["Parish"];
                    if (!String.IsNullOrEmpty(parishData))
                    {
                        var parishes = parishData.Split(',');
                        foreach (var parish in parishes)
                        {
                            application.Parishes.Add(parish);
                        }
                    }
                }

                if (result.Fields.Keys.Contains("nearestTownOrVillage"))
                {
                    application.NearestTownOrVillage = result.Fields["nearestTownOrVillage"];
                }

                if (result.Fields.Keys.Contains("statusClaimed"))
                {
                    application.StatusClaimed = result.Fields["statusClaimed"];
                }

                if (result.Fields.Keys.Contains("GridReference"))
                {
                    application.OrdnanceSurveyGridReference = result.Fields["GridReference"];
                }

                if (result.Fields.Keys.Contains("pageDescription"))
                {
                    application.DescriptionOfRoute = result.Fields["pageDescription"];
                }

                if (result.Fields.Keys.Contains("DateReceived"))
                {
                    application.DateReceived = new DateTime(Int32.Parse(result.Fields["DateReceived"].Substring(0, 4)), Int32.Parse(result.Fields["DateReceived"].Substring(4, 2)), Int32.Parse(result.Fields["DateReceived"].Substring(6, 2)));
                }

                if (result.Fields.Keys.Contains("nameOfApplicant"))
                {
                    application.IndividualApplicant = nameConverter.ConvertDataToSource(null, result.Fields["nameOfApplicant"], false) as PersonName;
                }

                if (result.Fields.Keys.Contains("nameOfApplicantOrganisation"))
                {
                    application.OrganisationalApplicant = result.Fields["nameOfApplicantOrganisation"];
                }

                if (result.Fields.Keys.Contains("councilOfficerAssigned"))
                {
                    application.CouncilOfficerAssigned = nameConverter.ConvertDataToSource(null, result.Fields["councilOfficerAssigned"], false) as PersonName;
                }

                if (result.Fields.Keys.Contains("applicationStatus"))
                {
                    application.ApplicationStatus = result.Fields["applicationStatus"];
                }

                if (result.Fields.Keys.Contains("decision"))
                {
                    application.Decision = result.Fields["decision"];
                }

                if (result.Fields.Keys.Contains("DateDetermined"))
                {
                    application.DateDetermined = new DateTime(Int32.Parse(result.Fields["DateDetermined"].Substring(0, 4)), Int32.Parse(result.Fields["DateDetermined"].Substring(4, 2)), Int32.Parse(result.Fields["DateDetermined"].Substring(6, 2)));
                }

                if (result.Fields.Keys.Contains("orderConfirmedDate"))
                {
                    application.DateModificationOrderConfirmed = new DateTime(Int32.Parse(result.Fields["orderConfirmedDate"].Substring(0, 4)), Int32.Parse(result.Fields["orderConfirmedDate"].Substring(4, 2)), Int32.Parse(result.Fields["orderConfirmedDate"].Substring(6, 2)));
                }

                model.ModificationOrderApplications.Add(application);
            }

            return(model);
        }