public override PipelineProcessorResponseValue ProcessRequest() { var itemTitle = RequestContext.Argument; if (ItemUtil.IsItemNameValid(itemTitle)) { var currentItem = RequestContext.Item; var currentBlog = ManagerFactory.BlogManagerInstance.GetCurrentBlog(currentItem); if (currentBlog != null) { var template = new TemplateID(currentBlog.BlogSettings.CategoryTemplateID); var categories = ManagerFactory.CategoryManagerInstance.GetCategoryRoot(currentItem); var newItem = ItemManager.AddFromTemplate(itemTitle, template, categories); return(new PipelineProcessorResponseValue { Value = newItem.ID.Guid }); } } return(new PipelineProcessorResponseValue { Value = null }); }
public static Item AddFromTemplateSynchronized([NotNull] this Database database, [NotNull] string itemName, [NotNull] ID templateId, [NotNull] Item destination, [NotNull] ID newItemId) { lock (SyncRoot) { return(ItemManager.AddFromTemplate(itemName, templateId, destination, newItemId)); } }
public string newPost(string blogid, string username, string password, XmlRpcStruct rpcstruct, bool publish) { Authenticate(username, password); CheckUserRights(blogid, username); var entryTitleRaw = rpcstruct["title"]; if (entryTitleRaw == null) { throw new ArgumentException("'title' must be provided"); } var entryTitle = entryTitleRaw.ToString(); var currentBlog = GetContentDatabase().GetItem(blogid); if (currentBlog != null) { BlogHomeItem blogItem = currentBlog; var template = new TemplateID(blogItem.BlogSettings.EntryTemplateID); var newItem = ItemManager.AddFromTemplate(entryTitle, template, currentBlog); SetItemData(newItem, rpcstruct); if (publish) { ContentHelper.PublishItemAndRequiredAncestors(newItem.ID); } return(newItem.ID.ToString()); } else { return(string.Empty); } }
private Item HandleDelete(Item newItem, string newItemName, CustomItemBase nItemTemplate, Item parent, object importRow) { if (PreserveChildren) { var temp = parent.Add("temp", new TemplateID(TemplateIDs.StandardTemplate)); foreach (Item child in newItem.Children.Where(x => x.TemplateID != ComponentsFolderTemplateId)) { child.MoveTo(temp); } newItem.Delete(); newItem = ItemManager.AddFromTemplate(newItemName, nItemTemplate.ID, parent, ((Item)importRow).ID); foreach (Item child in temp.Children) { child.MoveTo(newItem); } temp.Delete(); } else { newItem.Delete(); newItem = null; } return(newItem); }
public string newPost(string blogid, string username, string password, XmlRpcStruct rpcstruct, bool publish) { Authenticate(username, password); CheckUserRights(blogid, username); var entryTitle = rpcstruct["title"].ToString(); var currentBlog = ContentHelper.GetContentDatabase().GetItem(blogid); if (currentBlog != null) { // test var access = Sitecore.Security.AccessControl.AuthorizationManager.GetAccess(currentBlog, Sitecore.Context.User, Sitecore.Security.AccessControl.AccessRight.ItemCreate); // end test BlogHomeItem blogItem = currentBlog; var template = new TemplateID(blogItem.BlogSettings.EntryTemplateID); var newItem = ItemManager.AddFromTemplate(entryTitle, template, currentBlog); SetItemData(newItem, rpcstruct); if (publish) { ContentHelper.PublishItemAndRequiredAncestors(newItem.ID); } return(newItem.ID.ToString()); } else { return(string.Empty); } }
protected Item CreateTargetItem(SyncItem syncItem, Item destinationParentItem) { Database database = Factory.GetDatabase(syncItem.DatabaseName); if (destinationParentItem == null) { throw new ParentItemNotFoundException { ParentID = syncItem.ParentID, ItemID = syncItem.ID }; } var templateId = ID.Parse(syncItem.TemplateID); var itemId = ID.Parse(syncItem.ID); AssertTemplate(database, templateId, syncItem.ItemPath); Item targetItem = ItemManager.AddFromTemplate(syncItem.Name, templateId, destinationParentItem, itemId); if (targetItem == null) { throw new DeserializationException("Creating " + syncItem.DatabaseName + ":" + syncItem.ItemPath + " failed. API returned null."); } targetItem.Versions.RemoveAll(true); return(targetItem); }
protected MediaItem HandleMediaItem(IDataMap map, Item parentItem, string itemPath, MediaItem item) { var itemName = StringUtility.GetValidItemName(item.Name, 100); //date info string newFilePath = string.Format("{0}/{1}", parentItem.Paths.FullPath, itemName); // see if it exists in med lib IEnumerable <Item> matches = parentItem.Axes.GetDescendants() .Where(a => a.Paths.FullPath.EndsWith(itemName)); if (matches != null && matches.Any()) { if (matches.Count().Equals(1)) { return(new MediaItem(matches.First())); } map.Logger.Log("MediaFileMapping.HandleMediaItem", string.Format("Sitecore image lookup matched {0} for item {1}", matches.Count(), itemPath)); return(null); } ItemManager.AddFromTemplate(itemName, TemplateIDs.UnversionedImage, BuildMediaPath(map.ToDB, item.InnerItem.Paths.ParentPath), item.ID); MediaItem m = ImportMediaItem(item.GetMediaStream(), itemName + "." + item.Extension, newFilePath); if (m == null) { map.Logger.Log("MediaFileMapping.HandleMediaItem", string.Format("Image Not Found for item '{0}'", itemPath)); } return(m); }
protected Item CreateTargetItem(IItemData serializedItemData, Item destinationParentItem) { Database database = Factory.GetDatabase(serializedItemData.DatabaseName); if (destinationParentItem == null) { throw new ParentItemNotFoundException { ParentID = new ID(serializedItemData.ParentId).ToString(), ItemID = new ID(serializedItemData.Id).ToString() }; } AssertTemplate(database, new ID(serializedItemData.TemplateId), serializedItemData.Path); Item targetItem = ItemManager.AddFromTemplate(serializedItemData.Name, new ID(serializedItemData.TemplateId), destinationParentItem, new ID(serializedItemData.Id)); if (targetItem == null) { throw new DeserializationException("Creating " + serializedItemData.DatabaseName + ":" + serializedItemData.Path + " failed. API returned null."); } targetItem.Versions.RemoveAll(true); return(targetItem); }
private void UpdateSection([NotNull] Template template, [NotNull] Section section) { Debug.ArgumentNotNull(template, nameof(template)); Debug.ArgumentNotNull(section, nameof(section)); if (section.Item == null) { if (string.IsNullOrEmpty(section.ID)) { section.ID = Guid.NewGuid().ToString("B").ToUpperInvariant(); } section.Item = ItemManager.AddFromTemplate(section.Name, new TemplateID(TemplateIDs.TemplateSection), template.Item, new ID(section.ID)); } else { if (section.Item.ParentID != template.Item.ID) { section.Item.MoveTo(template.Item); } if (section.Item.Name != section.Name) { section.Item.Editing.BeginEdit(); section.Item.Name = section.Name; section.Item.Editing.EndEdit(); } } foreach (var field in section.Fields) { UpdateField(section, field); } }
private void UpdateField([NotNull] Section section, [NotNull] Field field) { Debug.ArgumentNotNull(section, nameof(section)); Debug.ArgumentNotNull(field, nameof(field)); if (field.Item == null) { if (string.IsNullOrEmpty(field.ID)) { field.ID = Guid.NewGuid().ToString("B").ToUpperInvariant(); } field.Item = ItemManager.AddFromTemplate(field.Name, new TemplateID(TemplateIDs.TemplateField), section.Item, new ID(field.ID)); } else if (field.Item.ParentID != section.Item.ID) { field.Item.MoveTo(section.Item); } field.Item.Editing.BeginEdit(); field.Item.Name = field.Name; field.Item["Type"] = field.Type; field.Item["Shared"] = field.Shared ? "1" : string.Empty; field.Item["Unversioned"] = field.Unversioned ? "1" : string.Empty; /* field.Item["Title"] = field.Title; */ field.Item["Source"] = field.Source; field.Item["Validator Bar"] = field.ValidatorBar; field.Item.Editing.EndEdit(); }
protected void Run(ClientPipelineArgs args) { if (args.IsPostBack) { if (args.HasResult) { var itemTitle = args.Result; var db = Sitecore.Configuration.Factory.GetDatabase(args.Parameters["database"]); if (db != null) { var currentItem = db.GetItem(args.Parameters["currentid"]); if (currentItem != null) { var currentBlog = ManagerFactory.BlogManagerInstance.GetCurrentBlog(currentItem); if (currentBlog != null) { var template = new TemplateID(currentBlog.BlogSettings.EntryTemplateID); Item newItem = ItemManager.AddFromTemplate(itemTitle, template, currentBlog); ContentHelper.PublishItem(newItem); } else { Log.Error("Failed to locate blog root item", this); } } } } } else { var db = Sitecore.Configuration.Factory.GetDatabase(args.Parameters["database"]); if (db == null) { return; } var currentItem = db.GetItem(args.Parameters["currentid"]); if (currentItem == null) { return; } if (!currentItem.TemplateIsOrBasedOn(Settings.BlogTemplateID) && !currentItem.TemplateIsOrBasedOn(Settings.EntryTemplateID)) { Context.ClientPage.ClientResponse.Alert("Please create or select a blog first"); } else { SheerResponse.Input("Enter the title of your new entry:", "", Configuration.Settings.ItemNameValidation, Translator.Text("'$Input' is not a valid title."), 100); args.WaitForPostBack(true); } } }
private void CreateNewTemplate([NotNull] Database database, [NotNull] Template template) { Debug.ArgumentNotNull(database, nameof(database)); Debug.ArgumentNotNull(template, nameof(template)); Item root = null; if (!string.IsNullOrEmpty(template.ParentPath)) { root = database.GetItem(template.ParentPath); if (root == null && !ID.IsID(template.ParentPath)) { var innerItem = database.GetItem(TemplateIDs.TemplateFolder); if (innerItem != null) { var templateFolder = new TemplateItem(innerItem); root = database.CreateItemPath(template.ParentPath, templateFolder, templateFolder); } } } if (root == null) { root = database.GetItem(ItemIDs.TemplateRoot); if (root == null) { return; } var item = root.Children["User Defined"]; if (item != null) { root = item; } } if (string.IsNullOrEmpty(template.ID)) { template.ID = Guid.NewGuid().ToString("B").ToUpperInvariant(); } template.Item = ItemManager.AddFromTemplate(template.Name, new TemplateID(TemplateIDs.Template), root, new ID(template.ID)); template.Item.Editing.BeginEdit(); template.Item[FieldIDs.BaseTemplate] = template.BaseTemplates; template.Item.Appearance.Icon = template.Icon; template.Item.Editing.EndEdit(); foreach (var section in template.Sections) { UpdateSection(template, section); } }
internal static void ImportPosts(Item blogItem, List <WpPost> listWordpressPosts, Database db, Action <string, int> logger = null) { BlogHomeItem customBlogItem = blogItem; var entryTemplate = TemplateManager.GetTemplate(customBlogItem.BlogSettings.EntryTemplateID, db); var processCount = 0; foreach (WpPost post in listWordpressPosts) { processCount++; if (!string.IsNullOrEmpty(post.Content)) { var name = ItemUtil.ProposeValidItemName(post.Title); if (logger != null) { logger(name, processCount); } EntryItem entry = ItemManager.AddFromTemplate(name, entryTemplate.ID, blogItem); entry.BeginEdit(); entry.Title.Field.Value = post.Title; entry.Introduction.Field.Value = string.Empty; entry.Content.Field.Value = post.Content; entry.Tags.Field.Value = string.Join(", ", post.Tags.ToArray()); var categorieItems = new List <string>(); foreach (string categoryName in post.Categories) { var categoryItem = ManagerFactory.CategoryManagerInstance.Add(categoryName, blogItem); categorieItems.Add(categoryItem.ID.ToString()); } if (categorieItems.Count > 0) { entry.Category.Field.Value = string.Join("|", categorieItems.ToArray()); } foreach (WpComment wpComment in post.Comments) { ManagerFactory.CommentManagerInstance.AddCommentToEntry(entry.ID, wpComment); } var publicationDate = DateUtil.ToIsoDate(post.PublicationDate); entry.InnerItem.Fields[FieldIDs.Created].Value = publicationDate; entry.InnerItem.Fields["Entry Date"].Value = publicationDate; entry.EndEdit(); } } }
protected virtual Item Create(string itemName, ID templateId, Item rootItem, ID itemId) { try { return(ItemManager.AddFromTemplate(itemName, templateId, rootItem, itemId)); } catch (Exception ex) { LogHelper.Error("Error during item creation. ItemId:" + itemId, this, ex); } return(null); }
private void CreateEaPlans() { var database = Context.ContentDatabase ?? Database.GetDatabase("master"); foreach (var plan in _eaPlanInfos) { var item = database.GetItem(ID.Parse(plan.EaPlanId)); if (item != null) { plan.Name = $"Storefront {item.DisplayName}"; ItemManager.AddFromTemplate(plan.Name, ID.Parse(plan.EaPlanId), database.GetItem(CommerceConnectEaPlanParentId), ID.Parse(plan.ItemId)); continue; } Log.Error($"Error creating engagement plan '{plan.Name}'.", this); } }
/// <summary> /// Creates the Engagement Plans /// </summary> protected virtual void CreateEaPlans() { var database = Context.ContentDatabase ?? Database.GetDatabase("master"); foreach (var plan in this._eaPlanInfos) { var item = database.GetItem(ID.Parse(plan.EaPlanId)); if (item != null) { plan.Name = string.Format(CultureInfo.InvariantCulture, EaPlanFormatString, StorefrontConstants.Settings.WebsiteName, item.DisplayName); var result = ItemManager.AddFromTemplate(plan.Name, ID.Parse(plan.EaPlanId), database.GetItem(StorefrontConstants.KnownItemIds.CommerceConnectEaPlanParentId), ID.Parse(plan.ItemId)); continue; } CommerceLog.Current.Error(string.Format(CultureInfo.InvariantCulture, "Error creating engagement plan '{0}'.", plan.Name), this); } }
protected void Run(ClientPipelineArgs args) { var db = ContentHelper.GetContentDatabase(); var currentItem = db.GetItem(args.Parameters["currentid"]); if (args.IsPostBack) { if (args.HasResult) { string itemTitle = args.Result; var blogItem = ManagerFactory.BlogManagerInstance.GetCurrentBlog(currentItem); if (blogItem == null) { SheerResponse.Alert("Failed to locate the blog item to add the category to.", true); return; } var template = new TemplateID(blogItem.BlogSettings.CategoryTemplateID); var categories = ManagerFactory.CategoryManagerInstance.GetCategoryRoot(currentItem); var newItem = ItemManager.AddFromTemplate(itemTitle, template, categories); ContentHelper.PublishItem(newItem); SheerResponse.Eval("scForm.browser.getParentWindow(scForm.browser.getFrameElement(window).ownerDocument).location.reload(true)"); args.WaitForPostBack(true); } } else { if (!currentItem.TemplateIsOrBasedOn(Settings.BlogTemplateID) && !currentItem.TemplateIsOrBasedOn(Settings.EntryTemplateID)) { Context.ClientPage.ClientResponse.Alert("Please create or select a blog first"); } else { SheerResponse.Input("Enter the name of your new category:", "", Configuration.Settings.ItemNameValidation, Translator.Text("'$Input' is not a valid name."), 100); args.WaitForPostBack(true); } } }
public void ShouldAddVersionOneWhenAddFromTemplate() { // arrange using (var db = new Db { new DbTemplate("Sample", this.templateId) { "Title" } }) { var root = db.GetItem("/sitecore/content"); // act var item = ItemManager.AddFromTemplate("home", this.templateId, root); // assert item.Versions.Count.Should().Be(1); } }
public static Item CreateIntegrationItem([NotNull] string itemName, [NotNull] Item destination, [NotNull] ID templateId, [NotNull] ID newId) { Assert.ArgumentNotNull(itemName, "itemName"); Assert.ArgumentNotNull(destination, "destination"); Assert.ArgumentNotNull(templateId, "templateId"); Assert.ArgumentNotNull(newId, "newId"); if (!IntegrationDisabler.CurrentValue && (IsActiveIntegrationConfigItem(destination) || IsActiveIntegrationFolder(destination))) { using (new IntegrationDisabler()) { return(ItemManager.AddFromTemplate(itemName, templateId, destination, newId)); } } return(null); }
/// <summary> /// Adds a new category. /// </summary> /// <param name="categoryName">Name of the category.</param> /// <param name="item">The item.</param> /// <returns></returns> public CategoryItem Add(string categoryName, Item item) { Item blogItem = item; var template = GetDatabase().GetTemplate(Settings.BlogTemplateID); if (template != null) { //Check if current item equals blogroot while (blogItem != null && !blogItem.TemplateIsOrBasedOn(template)) { blogItem = blogItem.Parent; } // Get all categories from current blog CategoryItem[] categories = GetCategories(blogItem); // If there are categories, check if it already contains the categoryName if (categories.Count() > 0) { var resultList = categories.Where(x => x.Title.Raw.ToLower() == categoryName.ToLower()); var result = resultList.Count() == 0 ? null : resultList.First(); // If category is found return ID if (result != null) { return(result); } } // Category doesn't exist so create it var categoriesFolder = blogItem.Axes.GetChild("Categories"); CategoryItem newCategory = ItemManager.AddFromTemplate(categoryName, new ID(CategoryItem.TemplateId), categoriesFolder); newCategory.BeginEdit(); newCategory.Title.Field.Value = categoryName; newCategory.EndEdit(); return(newCategory); } return(null); }
public void ShouldAddFromTemplate() { // arrange using (var db = new Db { new DbTemplate(this.templateId) }) { var destination = db.GetItem("/sitecore/content"); // act var result = ItemManager.AddFromTemplate(ItemName, this.templateId, destination, this.itemId); // assert db.GetItem("/sitecore/content/home").Should().NotBeNull(); result.Name.Should().Be(ItemName); result.ID.Should().Be(this.itemId); result.TemplateID.Should().Be(this.templateId); result.Parent.Should().Be(destination); } }
/// <summary> /// Adds a new category. /// </summary> /// <param name="categoryName">Name of the category.</param> /// <param name="item">The item.</param> /// <returns></returns> public virtual CategoryItem Add(string categoryName, Item item) { if (item == null) { Logger.Warn("Could not create a new category item because paremater 'item' was null", this); return(null); } // Get all categories from current blog var categories = GetCategories(item); // If there are categories, check if it already contains the categoryName if (categories.Any()) { var existingCategory = categories.Where(x => x.Title.Raw.CompareTo(categoryName) == 0); if (existingCategory.Any()) { return(existingCategory.First()); } } // Category doesn't exist so create it var categoryRoot = GetCategoryRoot(item) ?? CreateCategoryRoot(item); if (categoryRoot == null) { Logger.Warn("New category item cannot be created. Could not find the category root item.", this); return(null); } CategoryItem newCategory = ItemManager.AddFromTemplate(categoryName, Settings.CategoryTemplateIds.First(), categoryRoot); newCategory.BeginEdit(); newCategory.Title.Field.Value = categoryName; newCategory.EndEdit(); return(newCategory); }
public void ShouldCreateAndEditItemUsingItemManager() { // arrange using (var db = new Db { new DbTemplate("Sample", this.templateId) { "Title" } }) { var root = db.GetItem("/sitecore/content"); // act var item = ItemManager.AddFromTemplate("home", this.templateId, root); using (new EditContext(item)) { item["Title"] = "Hello"; } // assert item["Title"].Should().Be("Hello"); } }
public override PipelineProcessorResponseValue ProcessRequest() { var itemTitle = RequestContext.Argument; var currentItem = RequestContext.Item; var currentBlog = ManagerFactory.BlogManagerInstance.GetCurrentBlog(currentItem); if (currentBlog != null) { var template = new TemplateID(currentBlog.BlogSettings.EntryTemplateID); Item newItem = ItemManager.AddFromTemplate(itemTitle, template, currentBlog); ContentHelper.PublishItem(newItem); return(new PipelineProcessorResponseValue { Value = newItem.ID.Guid }); } return(new PipelineProcessorResponseValue { Value = null }); }
public static Item CreateItem( [NotNull] ID integrationItemID, [NotNull] ID integrationItemTemplateID, [NotNull] SharepointBaseItem sourceSharepointItem, [NotNull] SynchContext synchContext) { Assert.ArgumentNotNull(integrationItemID, "integrationItemID"); Assert.ArgumentNotNull(integrationItemTemplateID, "integrationItemTemplateID"); Assert.ArgumentNotNull(sourceSharepointItem, "sourceSharepointItem"); Assert.ArgumentNotNull(synchContext, "synchContext"); var validName = MediaPathManager.ProposeValidMediaPath(sourceSharepointItem.Title); Item integrationItem = ItemManager.AddFromTemplate(validName, integrationItemTemplateID, synchContext.ParentItem, integrationItemID); var folderItem = sourceSharepointItem as FolderItem; if (folderItem != null && integrationItem != null) { UpdateIntegrationConfigData(integrationItem, folderItem, synchContext); } return(integrationItem); }
public string Execute([NotNull] string databaseName, [NotNull] string itemId, [NotNull] string name, [NotNull] string location, [NotNull] string templateId) { var database = Factory.GetDatabase(databaseName); if (database == null) { throw new InvalidOperationException("Database not found"); } var owner = database.GetItem(itemId); if (owner == null) { throw new InvalidOperationException("Item not found"); } var templateItem = database.GetItem(templateId); if (owner == null) { throw new InvalidOperationException("Template item not found"); } Item parentItem; if (ID.IsID(location)) { parentItem = database.GetItem(location); } else { string path; if (string.IsNullOrEmpty(location)) { path = owner.Paths.Path; } else { path = location.StartsWith("/") ? location : owner.Paths.Path + "/" + location; } parentItem = database.GetItem(path); if (parentItem == null) { var folderTemplate = new TemplateItem(database.GetItem(TemplateIDs.Folder)); parentItem = database.CreateItemPath(path, folderTemplate); } } if (parentItem == null) { throw new InvalidOperationException("Location item not found"); } var newItemName = name + " Data Source"; var index = 2; while (parentItem.Children[newItemName] != null) { newItemName = name + " Data Source " + index; index++; } var newItem = ItemManager.AddFromTemplate(newItemName, templateItem.ID, parentItem); if (newItem == null) { throw new InvalidOperationException("Could not create data source item"); } return(newItem.ID + "," + parentItem.ID); }
internal ImportSummary ImportPosts(Item blogItem, TemplatesMapping mapping, Action <string, int> logger = null) { var summary = new ImportSummary(); var entryTemplate = TemplateManager.GetTemplate(mapping.BlogEntryTemplate, _db); foreach (WpPost post in Posts) { summary.PostCount++; if (!string.IsNullOrEmpty(post.Content)) { var title = post.Title; title = String.IsNullOrEmpty(title) ? $"Post {Posts.IndexOf(post)}" : title; var name = ItemUtil.ProposeValidItemName(title); if (logger != null) { logger(name, summary.PostCount); } EntryItem entry = ItemManager.AddFromTemplate(name, entryTemplate.ID, blogItem); entry.BeginEdit(); entry.Title.Field.Value = post.Title; entry.Introduction.Field.Value = string.Empty; entry.Content.Field.Value = post.Content; entry.Tags.Field.Value = string.Join(", ", post.Tags.ToArray()); var categorieItems = new List <string>(); foreach (string categoryName in post.Categories) { var categoryItem = ManagerFactory.CategoryManagerInstance.Add(categoryName, blogItem); categoryItem.InnerItem.ChangeTemplate(categoryItem.Database.GetItem(mapping.BlogCategoryTemplate)); categorieItems.Add(categoryItem.ID.ToString()); summary.CategoryCount++; } if (categorieItems.Count > 0) { entry.Category.Field.Value = string.Join("|", categorieItems.ToArray()); } foreach (WpComment wpComment in post.Comments) { var commentId = ManagerFactory.CommentManagerInstance.AddCommentToEntry(entry.ID, wpComment, blogItem.Language); var comment = entry.Database.GetItem(commentId, blogItem.Language); comment?.ChangeTemplate(comment.Database.GetItem(mapping.BlogCommentTemplate)); summary.CommentCount++; } var publicationDate = DateUtil.ToIsoDate(post.PublicationDate); entry.InnerItem.Fields[FieldIDs.Created].Value = publicationDate; entry.InnerItem.Fields["Entry Date"].Value = publicationDate; entry.EndEdit(); } } return(summary); }
private void ProcessComponents(Item parent, object importRow, IEnumerable <ComponentMapping> componentMappings) { using (new LanguageSwitcher(ImportToLanguage)) { //get the parent in the specific language foreach (var componentMapping in componentMappings ?? Enumerable.Empty <ComponentMapping>()) { try { if (!string.IsNullOrEmpty(componentMapping.Rendering) && !string.IsNullOrEmpty(componentMapping.Placeholder)) { CleanRenderings(parent, componentMapping.Rendering, componentMapping.Placeholder); } var items = componentMapping.GetImportItems((Item)importRow); foreach (var item in items) { if ((componentMapping.RequiredFields.Any())) { var requiredValues = GetFieldValues(componentMapping.RequiredFields, item); if (requiredValues.Any(x => string.IsNullOrEmpty(x))) { Logger.Log("SitecoreDataMap.ProcessComponents", string.Format("Missing required field for component {0} on item {1}", componentMapping.ComponentName, ((Item)item).ID)); continue; } } Item folder = parent; if (!string.IsNullOrEmpty(componentMapping.FolderName)) { var folderPath = parent.Paths.FullPath + "/" + componentMapping.FolderName; folder = ToDB.GetItem(folderPath); if (folder == null) { Logger.Log("SitecoreDataMap.ProcessComponents", string.Format("Could not find component Folder at {0}", folderPath)); folder = parent; } } var nItemTemplate = GetComponentItemTemplate(item, componentMapping); Item newItem; //search for the child by name var name = componentMapping.ComponentName; switch (name) { case "$name": case "@@name": name = item.Name; break; case "$outcomePostQuestionName": var questionName = item.Name.Replace('P', 'B'); name = GetChild(folder, questionName) != null ? questionName: item.Name; break; } newItem = GetChild(folder, name); if (newItem != null) //add version for lang { if (componentMapping.PreserveComponentId && newItem.ID != item.ID) { UpdateReferences(newItem, item.ID); newItem.Delete(); newItem = null; } else { newItem = newItem.Versions.AddVersion(); } } //if not found then create one if (newItem == null) { if (componentMapping.PreserveComponentId) { newItem = ItemManager.AddFromTemplate(name, nItemTemplate.ID, folder, item.ID); } else { newItem = ItemManager.AddFromTemplate(name, nItemTemplate.ID, folder); } } if (newItem == null) { throw new NullReferenceException("the new item created was null"); } using (new EditContext(newItem, true, false)) { ProcessFields(item, newItem, componentMapping); } using (new EditContext(newItem, true, false)) { ProcessReferenceFields(ref newItem, item, componentMapping.ReferenceFieldDefinitions); } using (new EditContext(newItem, true, false)) { ProcessComponents(newItem, item, componentMapping); } using (new EditContext(newItem, true, false)) { //calls the subclass method to handle custom fields and properties ProcessCustomData(ref newItem, item, componentMapping); } if (!string.IsNullOrEmpty(componentMapping.Rendering) && !string.IsNullOrEmpty(componentMapping.Placeholder)) { AddRendering(parent, componentMapping.Rendering, componentMapping.Placeholder, newItem); } Logger.Log("SitecoreDataMap.CreateNewItem", $"Import ID:{item.ID.Guid}, Import Path:{item.Paths.FullPath}, New ID:{newItem.ID.Guid}, New Path:{newItem.Paths.FullPath}"); } } catch (Exception ex) { Logger.Log("SitecoreDataMap.ProcessComponents", string.Format("failed to import component {0} on item {1}", componentMapping.ComponentName, parent.Paths.FullPath)); } } } }
protected virtual void Run(ClientPipelineArgs args) { //Cancel button if (args.IsPostBack && !args.HasResult) { return; } Database db = Factory.GetDatabase(args.Parameters["database"]); TemplateItem templateItem = db.Templates[this.GetTemplateId(args)]; Item parent = db.GetItem(this.GetParentId(args)); if (templateItem == null || parent == null) { return; } if (string.IsNullOrEmpty(this.GetEntityName(args))) { if (args.HasResult) { this.SetEntityName(args, args.Result); args.Result = "undefined"; } else { Context.ClientPage.ClientResponse.Input( Translate.Text(Texts.ENTER_THE_NAME_OF_THE_NEW_ITEM), templateItem.DisplayName, Settings.ItemNameValidation, Translate.Text(Texts.INPUT_IS_NOT_A_VALID_NAME), 100); args.WaitForPostBack(); } } if (!string.IsNullOrEmpty(this.GetEntityName(args)) && string.IsNullOrEmpty(this.GetEntityId(args))) { if (args.HasResult) { this.SetEntityId(args, args.Result); args.Result = "undefined"; } else { Context.ClientPage.ClientResponse.Input( Translate.Text(Translations.EnterTheEntityId), string.Empty, this.EntityIdValidation, Translate.Text(Texts.INPUT_IS_NOT_A_VALID_NAME), 100); args.WaitForPostBack(); } } string entityName = this.GetEntityName(args); string entityId = this.GetEntityId(args); if (string.IsNullOrEmpty(entityName) || string.IsNullOrEmpty(entityId)) { return; } Item accountItem = AccountManager.GetAccountItemForDescendant(parent); if (accountItem == null) { return; } ID itemId = this.GenerateItemId(args, accountItem); Item item = ItemManager.AddFromTemplate(entityName, templateItem.ID, parent, itemId); if (item == null) { return; } using (new EditContext(item)) { string entityIdField = this.GetEntityIdField(args); Assert.IsNotNullOrEmpty(entityIdField, "entityIdField is null or empty"); item[entityIdField] = entityId; string entityNameField = this.GetEntityNameField(args); if (!string.IsNullOrEmpty(entityNameField)) { item[entityNameField] = entityName; } } }
public override Item CreateNewItem(Item parent, object importRow, string newItemName) { CustomItemBase nItemTemplate = GetNewItemTemplate(importRow); newItemName = RewritePath(newItemName); using (new LanguageSwitcher(ImportToLanguage)) { //get the parent in the specific language parent = ToDB.GetItem(parent.ID); Item newItem; //search for the child by name if (AllowItemNameMatch) { newItem = GetChild(parent, newItemName); } else { newItem = ToDB.GetItem(((Item)importRow).ID); } if (newItem != null) //add version for lang { if (DeleteOnOverwrite) { newItem = HandleDelete(newItem, newItemName, nItemTemplate, parent, importRow); } else { if (newItem.ParentID != parent.ID) { newItem.MoveTo(parent); } newItem = newItem.Versions.AddVersion(); } } //if not found then create one if (newItem == null) { newItem = ItemManager.AddFromTemplate(newItemName, nItemTemplate.ID, parent, GetItemID(((Item)importRow))); } if (newItem == null) { throw new NullReferenceException("the new item created was null"); } //if found and is default template, change it to the correct one if (newItem.TemplateID == ImportToWhatTemplate.ID && nItemTemplate.ID != ImportToWhatTemplate.ID) { using (new EditContext(newItem, true, false)) { newItem.ChangeTemplate(new TemplateItem(nItemTemplate.InnerItem)); } } using (new EditContext(newItem, true, false)) { ProcessFields(importRow, newItem); } using (new EditContext(newItem, true, false)) { ProcessReferenceFields(ref newItem, importRow); } using (new EditContext(newItem, true, false)) { ProcessComponents(newItem, importRow); } using (new EditContext(newItem, true, false)) { //calls the subclass method to handle custom fields and properties ProcessCustomData(ref newItem, importRow); } Logger.Log("SitecoreDataMap.CreateNewItem", $"Import ID:{((Item) importRow).ID.Guid}, Import Path:{((Item)importRow).Paths.FullPath}, New ID:{newItem.ID.Guid}, New Path:{newItem.Paths.FullPath}"); return(newItem); } }