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;
}
