Custom migration behavior

1. Implement the ICustomMigrationBehavior interface.
   There are three main points where you can plug and intervene in the migration process using this interface:
   
• Using ProcessItemExport method - where you can modify the WrapperObject that will be sent to the destination
  
• Using ProcessItemImport method - where you validate the migration operation on the target and process the imported data
  
• Using HandleMigrationCompleted method - Handles the logic on the target server after the migration process completes

You can also use the SkipLoadingDependencies property - a value indicating whether implicitly syncing item dependencies should be skipped. You can set that to true, if you will migrate all items at once and the dependencies calculation will only slow things down.
You can see the sample below for an example of implementation.


	using System;
	using Telerik.Sitefinity.Data.ContentLinks;
	using Telerik.Sitefinity.DynamicModules.Model;
	using Telerik.Sitefinity.Model;
	using Telerik.Sitefinity.Publishing;
	using Telerik.Sitefinity.SiteSync;
	using Telerik.Sitefinity.Utilities.TypeConverters;
	namespace SitefinityWebApp
	{
	public class CustomMigrationBehavior : ICustomMigrationBehavior
	{
	/// <summary>
	/// Gets a value indicating whether implicitly syncing item dependencies should be skipped
	/// </summary>
	public bool SkipLoadingDependencies
	{
	get { return false; }
	}
	/// <summary>
	/// Prepares an item for migration
	/// </summary>
	/// <param name="item">The exported item</param>
	/// <param name="obj">The wrapper object containing exported information</param>
	/// <param name="context">The export context</param>
	public void ProcessItemExport(object item, WrapperObject obj, ISiteSyncExportContext context)
	{
	if (item is DynamicContent dynamicContent)
	{
	// Example on how to tell the destination server to create new item with different ID.
	// All properties of the WrapperObject could be altered here.
	this.MapForceCreateItem(dynamicContent, obj, context);
	}
	}
	/// <summary>
	/// Validates the import operation
	/// </summary>
	/// <param name="wrapperObject">The wrapper object containing import information</param>
	/// <param name="importTransaction">The import transaction</param>
	/// <returns>A value indicating whether the import operation is valid</returns>
	public bool ProcessItemImport(WrapperObject wrapperObject, ISiteSyncImportTransaction importTransaction)
	{
	var itemType = wrapperObject.GetPropertyOrDefault<string>(ObjectTypeId);
	var type = TypeResolutionService.ResolveType(itemType, false);
	if (type != null && typeof(DynamicContent).IsAssignableFrom(type))
	{
	// Example on how to change the "OriginalContentId" property to match the new item ID
	this.Map(importTransaction.Response.Mappings, wrapperObject, "OriginalContentId");
	}
	return true;
	}
	/// <summary>
	/// Handles the logic on the target server after migration completes
	/// </summary>
	/// <param name="migrationMappings">The migration mappings</param>
	/// <param name="siteInfo">The target site info</param>
	public void HandleMigrationCompleted(SiteSyncMigrationMappings migrationMappings, SiteSyncSiteInfo siteInfo)
	{
	var linksManager = ContentLinksManager.GetManager();
	var links = linksManager.GetContentLinks();
	foreach (var link in links)
	{
	this.Map(migrationMappings, link, "ChildItemId", link.ChildItemType);
	this.Map(migrationMappings, link, "ParentItemId", link.ParentItemType);
	}
	linksManager.SaveChanges();
	}
	#region Helper methods
	private void Map(SiteSyncMigrationMappings migrationMappings, object obj, string propertyName, string mapType = null, string mappedPropertyName = ItemId)
	{
	if (obj is WrapperObject wrapperObject)
	{
	var itemType = wrapperObject.GetPropertyOrDefault<string>(ObjectTypeId);
	if (wrapperObject.HasProperty(propertyName))
	{
	var mapping = migrationMappings.GetMapping(mapType ?? itemType, wrapperObject.GetProperty(propertyName).ToString(), mappedPropertyName);
	if (mapping != null)
	{
	var currentProp = wrapperObject.GetPropertyOrNull(propertyName);
	if (currentProp != null && currentProp.GetType() == typeof(Guid))
	{
	wrapperObject.SetProperty(propertyName, Guid.Parse(mapping));
	}
	else
	{
	wrapperObject.SetProperty(propertyName, mapping);
	}
	}
	}
	}
	else
	{
	var itemType = obj.GetType();
	var property = itemType.GetProperty(propertyName);
	if (property != null)
	{
	var mapping = migrationMappings.GetMapping(mapType ?? itemType.FullName, property.GetValue(obj, null).ToString(), mappedPropertyName);
	if (mapping != null)
	{
	if (property.PropertyType == typeof(Guid))
	{
	property.SetValue(obj, Guid.Parse(mapping));
	}
	else
	{
	property.SetValue(obj, mapping);
	}
	}
	}
	}
	}
	private void MapForceCreateItem(IDataItem dataItem, WrapperObject obj, ISiteSyncExportContext context)
	{
	var mapping = context.GetMapping(dataItem.GetType().FullName, dataItem.Id);
	if (mapping == null)
	{
	// The item is not existing on the target server and it should be created even if the item with same id already exists.
	obj.AddProperty(ForceCreateNewItem, true);
	}
	else
	{
	var newId = (Guid)mapping;
	// The item is already created on the target server.
	obj.AddProperty(Id, newId); // The identity of the item can't be changed, so we add the Id as additional property.
	obj.SetOrAddProperty(ObjectId, newId);
	}
	}
	#endregion
	private const string Id = "Id";
	private const string ItemId = "ItemId";
	private const string ObjectId = "objectId";
	private const string ObjectTypeId = "objectTypeId";
	private const string ForceCreateNewItem = "ForceCreateNewItem";
	}
	}

view raw custommigrationbehavior.cs hosted with ❤ by GitHub


2. Register the custom items in the Global.asax class.

You can see the sample below for an example on how to register your instance.



	using System;
	using Telerik.Microsoft.Practices.Unity;
	using Telerik.Sitefinity.Abstractions;
	using Telerik.Sitefinity.SiteSync;
	namespace SitefinityWebApp
	{
	public class Global : System.Web.HttpApplication
	{
	protected void Application_Start(object sender, EventArgs e)
	{
	// Subscribe to SiteSyncModule.Initialized
	SiteSyncModule.Initialized += SiteSyncModule_Initialized;
	}
	private void SiteSyncModule_Initialized(object sender, EventArgs e)
	{
	// Registering the custom ICustomMigrationBehavior implementation
	ObjectFactory.Container.RegisterInstance<ICustomMigrationBehavior>(new CustomMigrationBehavior());
	}
	}
	}

view raw custommigration_global.asax.cs hosted with ❤ by GitHub