コード例 #1
0
        /// <summary>
        /// Name of applicant is required but it can be in either of two fields. Standard required validation can't handle that, so check and return a custom error.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ContentService_Saving(IContentService sender, SaveEventArgs <IContent> e)
        {
            var nameConverter = new PersonNamePropertyValueConverter();

            foreach (IContent contentItem in e.SavedEntities)
            {
                try
                {
                    if (contentItem.ContentType.Alias == "RightsOfWayModification")
                    {
                        var individualApplicant   = nameConverter.ConvertDataToSource(null, contentItem.GetValue <string>("nameOfApplicant"), false) as PersonName;
                        var organisationApplicant = contentItem.GetValue <string>("nameOfApplicantOrganisation");
                        if (individualApplicant == null && string.IsNullOrEmpty(organisationApplicant))
                        {
                            e.CancelOperation(new EventMessage("Validation", "The applicant's name is required – either an individual or an organisation", EventMessageType.Error));
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogHelper.Error <Exception>($"Error validating the name of applicant fields for node {contentItem.Id}", ex);
                    ex.ToExceptionless().Submit();
                }
            }
        }
        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);
        }
        private void RightsOfWayEventHandler_GatheringNodeData(object sender, IndexingNodeDataEventArgs e)
        {
            if (e.IndexType == IndexTypes.Content)
            {
                try
                {
                    if (e.Fields.ContainsKey("nodeTypeAlias") && e.Fields["nodeTypeAlias"] == "RightsOfWayDeposit")
                    {
                        var combinedFields = new StringBuilder()
                                             .AppendLine(e.Fields["nodeName"]);

                        if (e.Fields.ContainsKey("Parish_Content"))
                        {
                            combinedFields.AppendLine(e.Fields["Parish_Content"]);
                        }

                        if (e.Fields.ContainsKey("pageDescription_Content"))
                        {
                            combinedFields.AppendLine(e.Fields["pageDescription_Content"]);
                        }

                        var ownerConverter = new PersonNamePropertyValueConverter();
                        for (var i = 1; i <= 5; i++)
                        {
                            if (e.Fields.ContainsKey($"Owner{i}_Content"))
                            {
                                var owner = ownerConverter.ConvertDataToSource(null, e.Fields[$"Owner{i}_Content"], false);
                                if (owner != null)
                                {
                                    combinedFields.AppendLine(owner.ToString());
                                }
                            }

                            if (e.Fields.ContainsKey($"OrganisationalOwner{i}_Content"))
                            {
                                combinedFields.AppendLine(e.Fields[$"OrganisationalOwner{i}_Content"]);
                            }

                            var locationPropertyAlias = $"Location{((i > 1) ? i.ToString(CultureInfo.InvariantCulture) : String.Empty)}_Content";
                            if (e.Fields.ContainsKey(locationPropertyAlias))
                            {
                                var locationJson = e.Fields[locationPropertyAlias];
                                if (!String.IsNullOrEmpty(locationJson))
                                {
                                    var address = JsonConvert.DeserializeObject <BS7666Address>(locationJson);
                                    combinedFields.AppendLine(address.ToString());
                                    combinedFields.AppendLine(address.Postcode?.Replace(" ", String.Empty));
                                }
                            }
                        }

                        e.Fields.Add("RightsOfWayDepositSearch", combinedFields.ToString());
                    }
                }
                catch (Exception ex)
                {
                    LogHelper.Error <Exception>($"Error combining fields into RightsOfWayDepositSearch Examine field for node {e.NodeId}", ex);
                    ex.ToExceptionless().Submit();
                }
            }
        }
コード例 #5
0
        private void RightsOfWayEventHandler_GatheringNodeData(object sender, IndexingNodeDataEventArgs e)
        {
            if (e.IndexType == IndexTypes.Content)
            {
                try
                {
                    if (e.Fields.ContainsKey("nodeTypeAlias") && e.Fields["nodeTypeAlias"] == "RightsOfWayModification")
                    {
                        var combinedFields = new StringBuilder()
                                             .AppendLine(e.Fields["nodeName"]);

                        if (e.Fields.ContainsKey("Parish"))
                        {
                            combinedFields.AppendLine(e.Fields["Parish"]);
                        }

                        if (e.Fields.ContainsKey("pageDescription"))
                        {
                            combinedFields.AppendLine(e.Fields["pageDescription"]);
                        }

                        if (e.Fields.ContainsKey("nearestTownOrVillage"))
                        {
                            combinedFields.AppendLine(e.Fields["nearestTownOrVillage"]);
                        }

                        if (e.Fields.ContainsKey("statusClaimed"))
                        {
                            combinedFields.AppendLine(e.Fields["statusClaimed"]);
                        }

                        var nameConverter = new PersonNamePropertyValueConverter();
                        if (e.Fields.ContainsKey("nameOfApplicant"))
                        {
                            var applicant = nameConverter.ConvertDataToSource(null, e.Fields["nameOfApplicant"], false);
                            if (applicant != null)
                            {
                                combinedFields.AppendLine(applicant.ToString());
                            }
                        }

                        if (e.Fields.ContainsKey("nameOfApplicantOrganisation"))
                        {
                            combinedFields.AppendLine(e.Fields["nameOfApplicantOrganisation"]);
                        }

                        if (e.Fields.ContainsKey("applicationStatus"))
                        {
                            combinedFields.AppendLine(e.Fields["applicationStatus"]);

                            // Add an extra field based on application status which tracks whether the application is completed
                            e.Fields.Add("RightsOfWayModificationComplete", (!string.IsNullOrEmpty(e.Fields["applicationStatus"]) && e.Fields["applicationStatus"].ToUpperInvariant().StartsWith("COMPLETE")).ToString().ToLowerInvariant());
                        }
                        else
                        {
                            e.Fields.Add("RightsOfWayModificationComplete", "false");
                        }

                        if (e.Fields.ContainsKey("decision"))
                        {
                            combinedFields.AppendLine(e.Fields["decision"]);
                        }

                        for (var i = 1; i <= 5; i++)
                        {
                            if (e.Fields.ContainsKey($"OrganisationalOwner{i}"))
                            {
                                combinedFields.AppendLine(e.Fields[$"OrganisationalOwner{i}"]);
                            }

                            if (e.Fields.ContainsKey($"Location{i}"))
                            {
                                var locationJson = e.Fields[$"Location{i}"];
                                if (!String.IsNullOrEmpty(locationJson))
                                {
                                    var address = JsonConvert.DeserializeObject <BS7666Address>(locationJson);
                                    combinedFields.AppendLine(address.ToString());
                                    combinedFields.AppendLine(address.Postcode?.Replace(" ", String.Empty));
                                }
                            }
                        }

                        e.Fields.Add("RightsOfWayModificationSearch", combinedFields.ToString());
                    }
                }
                catch (Exception ex)
                {
                    LogHelper.Error <Exception>($"Error combining fields into RightsOfWayModificationSearch Examine field for node {e.NodeId}", ex);
                    ex.ToExceptionless().Submit();
                }
            }
        }