public void MigrateItem(Item item) { if (ShouldMigrate(database.GetTemplate(item.TemplateID))) { TemplateItem oldTemplate = database.GetTemplate(item.TemplateID); TemplateItem newTemplate = GetVersionedMediaTemplateItem(oldTemplate); item.ChangeTemplate(newTemplate); Log.Info("Item modified: " + item.Paths.FullPath, this); Log.Info("Source template: " + oldTemplate.InnerItem.Paths.FullPath, this); Log.Info("Target template: " + newTemplate.InnerItem.Paths.FullPath, this); MakeVersionedFields(item); } else { Log.Info("Item skipped: " + item.Paths.FullPath, this); } }
protected void ChangeTemplateIfNeeded(IItemData serializedItemData, Item targetItem) { if (targetItem.TemplateID.Guid == serializedItemData.TemplateId) return; var oldTemplate = targetItem.Template; var newTemplate = targetItem.Database.Templates[new ID(serializedItemData.TemplateId)]; Assert.IsNotNull(newTemplate, "Cannot change template of {0} because its new template {1} does not exist!", targetItem.ID, serializedItemData.TemplateId); using (new EditContext(targetItem)) { targetItem.RuntimeSettings.ReadOnlyStatistics = true; try { targetItem.ChangeTemplate(newTemplate); } catch { // this generally means that we tried to sync an item and change its template AND we already deleted the item's old template in the same sync // the Sitecore change template API chokes if the item's CURRENT template is unavailable, but we can get around that // issure reported to Sitecore Support (406546) lock (targetItem.SyncRoot) { Template sourceTemplate = TemplateManager.GetTemplate(targetItem); Template targetTemplate = TemplateManager.GetTemplate(newTemplate.ID, targetItem.Database); Error.AssertNotNull(targetTemplate, "Could not get target in ChangeTemplate"); // this is probably true if we got here. This is the check the Sitecore API fails to make, and throws a NullReferenceException. if (sourceTemplate == null) sourceTemplate = targetTemplate; TemplateChangeList templateChangeList = sourceTemplate.GetTemplateChangeList(targetTemplate); TemplateManager.ChangeTemplate(targetItem, templateChangeList); } } } ClearCaches(targetItem.Database, targetItem.ID); targetItem.Reload(); _logger.ChangedTemplate(targetItem, oldTemplate); }
protected virtual bool UpdateItem(Item item, object importRow, string itemName, Item parentItem, ref LevelLogger logger) { var updateItemLogger = logger.CreateLevelLogger("Update Item"); var updatedItem = false; try { using (new LanguageSwitcher(ImportToLanguageVersion)) { using (new SecurityDisabler()) { if (AddLanguageVersionIfNoneExists(item, ref logger)) { updateItemLogger.IncrementCounter(IncrementConstants.LanguageVersionAdded); } // Move the item to it's correct position if (!DoNotMoveItemToParentFromImport) { if (item.ParentID != parentItem.ID) { MoveItem(item, parentItem, ref updateItemLogger); } } else { // When we do not move the item to it's importet parent, then we must set the parentItem to the currenct parent, to enable the validation of duplicate items names. parentItem = item.Parent; } if (OnDuplicateItemNamesGeneratePostfixNumber) { string errorMessage = ""; var checkIfItemNameLogger = updateItemLogger.CreateLevelLogger(); var newItemName = CheckIfItemNameIsUniqueAndGeneratePostFixNumberIfNot(importRow, item, itemName, itemName, parentItem, 1, ref checkIfItemNameLogger); if (checkIfItemNameLogger.HasErrors()) { checkIfItemNameLogger.AddError("Error in 'CheckIfItemNameIsUniqueAndGeneratePostFixNumberIfNot'", String.Format( "The 'CheckIfItemNameIsUniqueAndGeneratePostFixNumberIfNot' method failed with an error. The itemname was not changed to a postfixnumber since the check failed. But the Update process was continued. ImportRow: {0}. ErrorMessage: {1}", GetImportRowDebugInfo(importRow), errorMessage)); logger.IncrementCounter(IncrementConstants.FailureItems); } if (!itemName.Equals(newItemName)) { updateItemLogger.AddInfo("Item name regenerated", String.Format("The item name '{0}' was regenerated to '{1}' to avoid duplicate item name.", itemName, newItemName)); itemName = newItemName; logger.IncrementCounter(IncrementConstants.ItemNameRegenerated); } } if(OnDuplicateItemNamesGeneratePostfixNumber || UpdateItemName) { if (item.Name != itemName) { item.Editing.BeginEdit(); updateItemLogger.AddInfo("Item name updated", String.Format("The item name '{0}' was updated to '{1}'.", item.Name, itemName)); item.Name = itemName; item.Editing.EndEdit(); logger.IncrementCounter(IncrementConstants.RenamedItems); } } if (ValidateIfItemKeyIsUnique) { if (!IsItemNameUnique(parentItem, item, ref updateItemLogger)) { // The validation of the item found that there exists more than one item under the parent with the same item key. // We logged the error, but continue processing item. The duplicated item names must be corrected manually. updateItemLogger.IncrementCounter(IncrementConstants.FailureItems); return false; } } // Change template if type has changed and we are not explicit told not to if (!DoNotChangeTemplate && ToWhatTemplates.Count > 0) { string errorMessage = String.Empty; var getToWhatLogger = updateItemLogger.CreateLevelLogger(); var toWhatTemplate = GetToWhatTemplateItem(importRow, ref getToWhatLogger); if (getToWhatLogger.HasErrors()) { getToWhatLogger.AddError("Failure in 'GetToWhatTemplateItem' method", String.Format( "The 'GetToWhatTemplateItem' method failed with an error. ImportRow: {0}. Therefor it was not possible to determine wheether the item template should change. The Change template process was aborted as well as the rest of the update item process. {1}", GetImportRowDebugInfo(importRow), errorMessage)); updateItemLogger.IncrementCounter(IncrementConstants.FailureItems); return false; } if (toWhatTemplate != null) { var templateItem = toWhatTemplate as TemplateItem; if (templateItem != null) { if (item.TemplateID != toWhatTemplate.ID) { string fromTemplateDebugInfo = GetTemplateDebugInfo(item.Template); item.Editing.BeginEdit(); item.ChangeTemplate(templateItem); updateItemLogger.AddInfo("Change Template", String.Format("Changed template from '{0}' to '{1}'.", fromTemplateDebugInfo, GetTemplateDebugInfo(item.Template))); item.Editing.EndEdit(); updateItemLogger.IncrementCounter(IncrementConstants.ChangedTemplate); } } } else { updateItemLogger.IncrementCounter(IncrementConstants.FailureItems); return false; } } // Add in the field mappings var updatedFields = false; var failedItem = false; item.Editing.BeginEdit(); foreach (IBaseField fieldDefinition in FieldDefinitions) { var fieldLogger = updateItemLogger.CreateLevelLogger("Field"); string errorMessage = String.Empty; var existingFieldNames = fieldDefinition.GetExistingFieldNames(); var fieldValueDelimiter = fieldDefinition.GetFieldValueDelimiter(); fieldLogger.AddKey("FieldName", fieldDefinition.GetNewItemField()); fieldLogger.AddKey("ImportRowFieldName", String.Join(fieldValueDelimiter, fieldDefinition.GetExistingFieldNames().ToArray())); var getFieldLogger = fieldLogger.CreateLevelLogger(); IEnumerable<string> values = GetFieldValues(existingFieldNames, importRow, ref getFieldLogger); if (getFieldLogger.HasErrors()) { getFieldLogger.AddError("Error in extracting a value from a field", String.Format("An error occured in extracting the values from a specific field: '{0}' on the item: '{1}'. The processing of the item is aborted and no fields has been updated. ErrorMessage: {2}", fieldDefinition, GetItemDebugInfo(item), errorMessage)); updateItemLogger.IncrementCounter(IncrementConstants.FailureItems); return false; } bool updateField; var importValue = String.Join(fieldValueDelimiter, values.ToArray()); var fieldDefinitionLogger = fieldLogger.CreateLevelLogger(); fieldDefinition.FillField(this, importRow, ref item, importValue, out updateField, ref fieldDefinitionLogger); if (fieldDefinitionLogger.HasErrors()) { fieldDefinitionLogger.AddError("Error processing a field", String.Format("An error occured in processing a field on the item: '{0}'. The processing of the item in itself is not aborted and the rest of the fields has been processed.", GetItemDebugInfo(item))); failedItem = true; } if (updateField) { fieldLogger.AddInfo("Update Field", String.Format("The field '{0}' was updated.", fieldDefinition.GetNewItemField())); updatedFields = true; } } if (updatedFields) { item.Editing.EndEdit(); updateItemLogger.AddInfo("Updated Field on Item", String.Format("The item had fields that were updated.")); updateItemLogger.IncrementCounter(IncrementConstants.UpdatedFields); } else { item.Editing.CancelEdit(); } if (failedItem) { updateItemLogger.IncrementCounter(IncrementConstants.FailureItems); return false; } // Calls the subclass method to handle custom fields and properties bool processedCustomData; if (!ProcessCustomData(ref item, importRow, out processedCustomData)) { updateItemLogger.IncrementCounter(IncrementConstants.FailureItems); return false; } if (processedCustomData) { updateItemLogger.AddInfo("Custom Data processed", String.Format("Custom data was processed on item.")); updateItemLogger.IncrementCounter(IncrementConstants.ProcessedCustomData); } } } } catch (Exception ex) { updateItemLogger.AddError("Exception occured in UpdateItem method", String.Format("An exception occured in UpdateItem. ImportRow: {0}. Item: {1}, ItemName: {2}, Exception: {3}", GetImportRowDebugInfo(importRow), GetItemDebugInfo(item), itemName, GetExceptionDebugInfo(ex))); updateItemLogger.IncrementCounter(IncrementConstants.FailureItems); return false; } return true; }