public void OnItemAdded([CanBeNull] object sender, [NotNull] EventArgs args)
        {
            Assert.ArgumentNotNull(args, "args");

            var contentItem = Event.ExtractParameter(args, 0) as Item;

            Assert.IsNotNull(contentItem, "targetItem");

            var branchItem = contentItem.Branch;

            if (branchItem == null)
            {
                return;
            }

            var item = branchItem.InnerItem;

            Assert.IsTrue(item.Children.Count == 1, "branch item structure is corrupted: {0}".FormatWith(AuditFormatter.FormatItem(item)));


            var branch = item.Children[0];

            if (this.isAsync)
            {
                ReferenceReplacementJob.StartAsync(branch, contentItem);
            }
            else
            {
                ReferenceReplacementJob.Start(branch, contentItem);
            }
        }
Exemple #2
0
        public void Process([NotNull] CopyItemsArgs args)
        {
            Assert.ArgumentNotNull(args, "args");

            var parameters = args.Parameters;

            Assert.IsNotNull(parameters, "parameters");

            if (!string.Equals(parameters["mode"], "smart", StringComparison.OrdinalIgnoreCase))
            {
                return;
            }


            var copies = args.Copies;

            Assert.IsNotNull(copies, "copies");

            foreach (var copy in copies)
            {
                if (this.isAsync)
                {
                    ReferenceReplacementJob.StartAsync(copy.Source, copy);
                }
                else
                {
                    ReferenceReplacementJob.Start(copy.Source, copy);
                }
            }

            // if mode is smart then this should be the last processor
            args.AbortPipeline();
        }
        public void Process([NotNull] ClientPipelineArgs args)
        {
            Assert.ArgumentNotNull(args, "args");

            var parameters = args.Parameters;

            Assert.IsNotNull(parameters, "parameters");

            if (!string.Equals(parameters["mode"], "smart", StringComparison.OrdinalIgnoreCase))
            {
                return;
            }

            var databaseName = parameters["database"];
            var database     = Factory.GetDatabase(databaseName);

            Assert.IsNotNull(database, "database");

            var copyId = parameters["copyId"];

            Assert.IsNotNull(copyId, "copyId");

            var sourceId = parameters["id"];

            Assert.IsNotNull(sourceId, "sourceId");

            if (this.isAsync)
            {
                ReferenceReplacementJob.StartAsync(database, sourceId, copyId);
            }
            else
            {
                ReferenceReplacementJob.Start(database, sourceId, copyId);
            }

            // if mode is smart then this should be the last processor
            args.AbortPipeline();
        }
        public void ReferenceReplacementJobTest()
        {
            using (var db = new Db("master"))
            {
                var sourceRoot        = Sitecore.Data.ID.NewID;
                var sourceChild1      = Sitecore.Data.ID.NewID;
                var sourceGrandChild1 = Sitecore.Data.ID.NewID;
                var sourceChild2      = Sitecore.Data.ID.NewID;

                // TODO: make this test for versioned, unversioned and shared fields
                var sourceRootItem =
                    new DbItem("SourceRoot", sourceRoot)
                {
                    new DbField("Root")
                    {
                        Value = sourceRoot.ToString(), Type = "droptree"
                    },
                    new DbField("Child1")
                    {
                        Value = sourceChild1.ToString(), Type = "droptree"
                    },
                    new DbField("GrandChild1")
                    {
                        Value = sourceGrandChild1.ToString(), Type = "droptree"
                    },
                    new DbField("Child2")
                    {
                        Value = sourceChild2.ToString(), Type = "droptree"
                    },

                    new DbItem("SourceChild1", sourceChild1)
                    {
                        new DbField("Root")
                        {
                            Value = sourceRoot.ToString(), Type = "droptree"
                        },
                        new DbField("Child1")
                        {
                            Value = sourceChild1.ToString(), Type = "droptree"
                        },
                        new DbField("GrandChild1")
                        {
                            Value = sourceGrandChild1.ToString(), Type = "droptree"
                        },
                        new DbField("Child2")
                        {
                            Value = sourceChild2.ToString(), Type = "droptree"
                        },

                        new DbItem("SourceGrandChild1", sourceGrandChild1)
                        {
                            new DbField("Root")
                            {
                                Value = sourceRoot.ToString(), Type = "droptree"
                            },
                            new DbField("Child1")
                            {
                                Value = sourceChild1.ToString(), Type = "droptree"
                            },
                            new DbField("GrandChild1")
                            {
                                Value = sourceGrandChild1.ToString(), Type = "droptree"
                            },
                            new DbField("Child2")
                            {
                                Value = sourceChild2.ToString(), Type = "droptree"
                            },
                        }
                    },
                    new DbItem("SourceChild2", sourceChild2)
                    {
                        new DbField("Root")
                        {
                            Value = sourceRoot.ToString(), Type = "droptree"
                        },
                        new DbField("Child1")
                        {
                            Value = sourceChild1.ToString(), Type = "droptree"
                        },
                        new DbField("GrandChild1")
                        {
                            Value = sourceGrandChild1.ToString(), Type = "droptree"
                        },
                        new DbField("Child2")
                        {
                            Value = sourceChild2.ToString(), Type = "droptree"
                        },
                    }
                };

                db.Add(sourceRootItem);

                var item11   = db.GetItem(sourceRoot);
                var copyRoot = item11.Duplicate("copyRoot");

                ReferenceReplacementJob.Start(db.Database, sourceRoot, copyRoot.ID);
                var id = copyRoot.ID;
                copyRoot = db.Database.GetItem(id);
                copyRoot["Root"].Should().NotBeEmpty().And.NotBe(sourceRoot.ToString());
                copyRoot["Child1"].Should().NotBeEmpty().And.NotBe(sourceChild1.ToString());
                copyRoot["GrandChild1"].Should().NotBeEmpty().And.NotBe(sourceGrandChild1.ToString());
                copyRoot["Child2"].Should().NotBeEmpty().And.NotBe(sourceChild2.ToString());

                foreach (var descendant in copyRoot.Axes.GetDescendants())
                {
                    descendant["Root"].Should().NotBeEmpty().And.NotBe(sourceRoot.ToString());
                    descendant["Child1"].Should().NotBeEmpty().And.NotBe(sourceChild1.ToString());
                    descendant["GrandChild1"].Should().NotBeEmpty().And.NotBe(sourceGrandChild1.ToString());
                    descendant["Child2"].Should().NotBeEmpty().And.NotBe(sourceChild2.ToString());
                }
            }
        }