public async Task <TaxonomyValidationResult> Validate(TaxonomyPart part)
        {
            if (part.TermContentType != ContentTypes.PageLocation)
            {
                return(new TaxonomyValidationResult(true, null));
            }

            List <string> errors = new List <string>();

            //make sure nothing has moved that has associated pages anywhere down the tree
            List <ContentItem> allPages = await _contentItemsService.GetActive(ContentTypes.Page);

            JArray?terms = _taxonomyHelper.GetAllTerms(JObject.FromObject(part.ContentItem));

            if (terms != null)
            {
                foreach (JObject term in terms)
                {
                    dynamic?originalParent = _taxonomyHelper.FindParentTaxonomyTerm(term, JObject.FromObject(part.ContentItem));
                    dynamic?newParent      = _taxonomyHelper.FindParentTaxonomyTerm(term, JObject.FromObject(part));

                    if (originalParent == null || newParent == null)
                    {
                        throw new InvalidOperationException($"Could not find {(originalParent == null ? "original" : "new")} parent taxonomy term for {term}");
                    }

                    if (newParent?.ContentItemId != null && newParent?.ContentItemId != originalParent?.ContentItemId)
                    {
                        //find all child terms down the taxonomy tree
                        var childTermsFromTree = _taxonomyHelper.GetAllTerms(term);

                        if (allPages.Any(x => (string)x.Content.Page.PageLocations.TermContentItemIds[0] == (string)term["ContentItemId"] ! || childTermsFromTree.Any(t => (string)t["ContentItemId"] ! == (string)x.Content.Page.PageLocations.TermContentItemIds[0])))
                        {
                            errors.Add("You cannot move a Page Location which has associated Pages linked to it, or any of its children.");
                        }

                        foreach (var validator in _validators)
                        {
                            (bool validated, string errorMessage) =
                                await validator.ValidateUpdate(term, JObject.FromObject(part));

                            if (!validated)
                            {
                                errors.Add(errorMessage);
                            }
                        }

                        //make sure display text doesn't clash with any other term at this level
                        JArray parentTerms = _taxonomyHelper.GetTerms(JObject.FromObject(newParent));
                        if (parentTerms?.Any(x => (string)x["ContentItemId"] ! != (string)term["ContentItemId"] ! && (string)x["DisplayText"] ! == (string)term["DisplayText"] !) ?? false)
                        {
                            errors.Add("Terms at the same hierarchical position must have unique titles.");
                        }
                    }
                }
            }

            return(new TaxonomyValidationResult(!errors.Any(), errors));
        }
        public async Task <(bool, string)> ValidateUpdate(JObject term, JObject taxonomy)
        {
            if (!term.ContainsKey("PageLocation"))
            {
                return(true, string.Empty);
            }

            List <ContentItem> allPages = await _contentItemsService.GetActive(ContentTypes.Page);

            //find all child terms down the taxonomy tree
            var childTermsFromTree = _taxonomyHelper.GetAllTerms(term);

            if (allPages.Any(x => (string)x.Content.Page.PageLocations.TermContentItemIds[0] == (string)term["ContentItemId"] ! || childTermsFromTree.Any(t => (string)t["ContentItemId"] ! == (string)x.Content.Page.PageLocations.TermContentItemIds[0])))
            {
                return(false, "Page Locations with pages associated to them or any of their children cannot be changed or deleted.");
            }

            return(true, string.Empty);
        }
Пример #3
0
        public override async Task MutateOnClone(JObject content, ICloneContext context)
        {
            string?urlName = (string?)content[nameof(PageLocationPart.UrlName)];
            string?fullUrl = (string?)content[nameof(PageLocationPart.FullUrl)];

            if (string.IsNullOrWhiteSpace(urlName) || string.IsNullOrWhiteSpace(fullUrl))
            {
                throw new InvalidOperationException($"Cannot mutate {nameof(PageLocationPart)} if {nameof(PageLocationPart.UrlName)} or {nameof(PageLocationPart.FullUrl)} are missing.");
            }

            List <ContentItem> pages = await _contentItemsService.GetActive(ContentTypes.Page);

            string urlSearchFragment = _generator.GenerateUrlSearchFragment(fullUrl);

            IEnumerable <ContentItem> existingClones = pages.Where(x => ((string)x.Content[nameof(PageLocationPart)][nameof(PageLocationPart.FullUrl)]).Contains(urlSearchFragment));

            var result = _generator.GenerateClonedPageLocationProperties(urlName, fullUrl, existingClones);

            content[nameof(PageLocationPart.UrlName)] = result.UrlName;
            content[nameof(PageLocationPart.FullUrl)] = result.FullUrl;
            content[nameof(PageLocationPart.DefaultPageForLocation)] = false;
            content[nameof(PageLocationPart.RedirectLocations)]      = null;
        }
Пример #4
0
        public async Task <bool> UpdatedAsync(ContentItem term, ContentItem taxonomy)
        {
            if (term.ContentType != ContentTypes.PageLocation)
            {
                return(true);
            }

            List <ContentItem> allPages = await _contentItemsService.GetActive(ContentTypes.Page);

            List <ContentItem> associatedPages = allPages.Where(x => x.Content.Page.PageLocations.TermContentItemIds[0] == term.ContentItemId).ToList();

            var groups = associatedPages.GroupBy(x => x.ContentItemId);

            foreach (var group in groups)
            {
                var pages = group.ToList();

                foreach (var page in pages)
                {
                    //rebuild the Full URL to ensure it matches the current state of the term
                    var pageUrlName = page.As <PageLocationPart>().UrlName;
                    var termUrl     = _taxonomyHelper.BuildTermUrl(JObject.FromObject(term), JObject.FromObject(taxonomy));

                    var fullUrl = string.IsNullOrWhiteSpace(termUrl)
                        ? $"/{pageUrlName}"
                        : $"/{termUrl}/{pageUrlName}";

                    page.Alter <PageLocationPart>(part => part.FullUrl = fullUrl);

                    _session.Save(page);
                }

                try
                {
                    if (pages.Count > 1)
                    {
                        var publishedPage = pages.Single(x => x.Published);
                        var draftPage     = pages.Single(x => x.Latest);

                        if (!await _syncOrchestrator.Update(publishedPage, draftPage))
                        {
                            _session.Cancel();
                        }
                    }
                    else
                    {
                        var page = pages.Single();

                        if (page.Published && !await _syncOrchestrator.Publish(page))
                        {
                            _session.Cancel();
                        }
                        else if (!page.Published && !await _syncOrchestrator.SaveDraft(page))
                        {
                            _session.Cancel();
                        }
                    }
                }
                catch (Exception)
                {
                    _session.Cancel();
                    return(false);
                }
            }

            return(true);
        }