public static void CopyFieldValues(
[NotNull] Item sourceIntegrationItem,
[NotNull] SharepointBaseItem targetSharepointItem,
[NotNull] IntegrationConfigData integrationConfigData)
{
Assert.ArgumentNotNull(sourceIntegrationItem, "sourceIntegrationItem");
Assert.ArgumentNotNull(targetSharepointItem, "targetSharepointItem");
Assert.ArgumentNotNull(integrationConfigData, "integrationConfigData");
foreach (IntegrationConfigData.FieldMapping fieldMapping in integrationConfigData.FieldMappings)
{
if (sourceIntegrationItem.Fields[fieldMapping.Target] == null)
{
continue;
}
TranslateIntegrationValueArgs pipelineArgs = TranslateSynchValuePipelinesRunner.TranslateIntegrationValue(
sourceIntegrationItem,
fieldMapping.Target,
targetSharepointItem,
fieldMapping.Source);
if (pipelineArgs != null && !(String.IsNullOrEmpty(targetSharepointItem[fieldMapping.Source]) && String.IsNullOrEmpty(pipelineArgs.TranslatedValue)))
{
targetSharepointItem[fieldMapping.Source] = pipelineArgs.TranslatedValue;
}
}
}
public void should_request_items_with_correct_options()
{
// Arrange
var configData = new IntegrationConfigData("server", "list", "templateID")
{
ItemLimit = 100500,
Folder = "SomeFolder",
View = "SomeView"
};
var context = Substitute.For <SpContext>();
var list = Substitute.For <BaseList>(new EntityValues(), context, new Uri("http://empty"));
var myItemCollection = new MyItemCollection(context, list, new ItemsRetrievingOptions());
list.GetItems(Arg.Any <ItemsRetrievingOptions>()).Returns(myItemCollection);
this.sharepointListProvider.GetList(string.Empty, string.Empty, null).ReturnsForAnyArgs(list);
var args = new SynchronizeTreeArgs
{
Context = this.CreateSynchContext(configData)
};
// Act
this.processor.Process(args);
// Assert
list.Received().GetItems(Arg.Is <ItemsRetrievingOptions>(x => x.ItemLimit == configData.ItemLimit && x.Folder == configData.Folder && x.ViewName == configData.View));
}
public static ItemMock CreateConfigurationItem(
this Database database,
string guidValue = "",
bool isIntegrationValue = true,
IntegrationConfigData configData = null)
{
return(new ItemMock(ID.NewID, database).AsConfigurationItem(configData, guidValue, isIntegrationValue));
}
/// <summary>Create data context.</summary>
/// <param name="integrationConfigData">The integration config data.</param>
/// <returns>The <see cref="SpContext"/>.</returns>
public override SpContext CreateDataContext(IntegrationConfigData integrationConfigData)
{
return(this.CreateDataContext(
integrationConfigData.Server,
integrationConfigData.Web,
integrationConfigData.Credentials,
integrationConfigData.ConnectionConfiguration));
}
public static ItemMock PutConfigDataToCache(this ItemMock item, IntegrationConfigData configData = null)
{
IntegrationCache.AddIntegrationConfigData(
item.ID,
configData ?? new IntegrationConfigData("server", "list", "templateID"),
60);
return(item);
}
protected BaseList GetList([NotNull] IntegrationConfigData integrationConfigData)
{
Assert.ArgumentNotNull(integrationConfigData, "integrationConfigData");
var context = SpContextProviderBase.Instance.CreateDataContext(integrationConfigData);
return(BaseList.GetList(integrationConfigData.Web, integrationConfigData.List, context));
}
/// <summary>
/// Add specified integration configuration data to the Cache.
/// </summary>
/// <param name="itemId">
/// The item id.
/// </param>
/// <param name="integrationConfigData">
/// The info.
/// </param>
/// <param name="expiredInSeconds">
/// The expired in seconds.
/// </param>
protected void DoAddIntegrationConfigData(ID itemId, IntegrationConfigData integrationConfigData, ulong expiredInSeconds)
{
SetObject(FolderPrefix + itemId,
new CacheableIntegrationConfigData()
{
ExpirationDate = DateTime.Now.AddSeconds(expiredInSeconds), Data = integrationConfigData
});
}
public bool UpdateItemsGuid(Item item)
{
IntegrationConfigData integrationData = null;
try
{
integrationData = IntegrationConfigDataProvider.GetFromItem(item);
Assert.IsNotNull(integrationData, "integrationData");
var context = SpContextProviderBase.Instance.CreateDataContext(integrationData);
var list = BaseList.GetList(integrationData.Web, integrationData.List, context);
Assert.IsNotNull(list, "list");
var itemCollection = list.GetItems(new ItemsRetrievingOptions
{
Folder = integrationData.Folder,
ItemLimit = integrationData.ItemLimit,
ViewName = integrationData.View
});
foreach (var listItem in itemCollection)
{
var connectedItem = this.GetConnectedItem(item, listItem, list);
if (connectedItem != null)
{
using (new SecurityDisabler())
{
new IntegrationItem(connectedItem).GUID = listItem.GUID;
}
if (listItem is FolderItem)
{
this.UpdateItemsGuid(connectedItem);
}
}
}
return(true);
}
catch (Exception exception)
{
var errorMessage = new StringBuilder("Updating guids have been failed.");
errorMessage.AppendLine(string.Format("Integration config item: {0}", item.ID));
if (integrationData != null)
{
errorMessage.AppendLine(LogMessageFormatter.FormatWeb01List23(integrationData));
}
Log.Error(errorMessage.ToString(), exception, this);
return(false);
}
}
private SynchContext CreateSynchContext(IntegrationConfigData integrationConfigData)
{
var id = ID.NewID;
IntegrationCache.AddIntegrationConfigData(id, integrationConfigData, 0);
var synchContext = new SynchContext(id, Substitute.For <Database>());
return(synchContext);
}
public static string FormatText0Item1([NotNull] IntegrationConfigData integrationConfigData, [NotNull] string itemName)
{
Assert.ArgumentNotNull(integrationConfigData, "integrationConfigData");
Assert.ArgumentNotNullOrEmpty(itemName, "itemName");
return(string.Format(
LogMessages.Text0Item1,
FormatWeb01List23(integrationConfigData),
itemName));
}
public static string FormatWeb01List23([NotNull] IntegrationConfigData data)
{
Assert.ArgumentNotNull(data, "data");
return(string.Format(
LogMessages.Web01List23,
data.Server.Trim('/'),
string.IsNullOrEmpty(data.Web) ? string.Empty : StringUtil.EnsurePrefix('/', data.Web.TrimEnd('/')),
data.List,
string.IsNullOrEmpty(data.Folder) ? string.Empty : " Folder: " + data.Folder.Trim('/')));
}
/// <summary>
/// Set integration configuration data for integration folder or integration configuration item.
/// </summary>
/// <param name="synchContext">The synchronization context.</param>
/// <param name="sourceSharepointFolderItem">The source.</param>
/// <param name="targetIntegrationItem">The item .</param>
private static void UpdateIntegrationConfigData([NotNull] Item targetIntegrationItem, [NotNull] FolderItem sourceSharepointFolderItem, [NotNull] SynchContext synchContext)
{
Assert.ArgumentNotNull(targetIntegrationItem, "targetIntegrationItem");
Assert.ArgumentNotNull(sourceSharepointFolderItem, "sourceSharepointFolderItem");
Assert.ArgumentNotNull(synchContext, "synchContext");
IntegrationConfigData integrationConfigData = synchContext.IntegrationConfigData.Clone();
integrationConfigData.Folder = StringUtil.RemovePrefix('/', StringUtil.EnsurePostfix('/', synchContext.IntegrationConfigData.Folder) + sourceSharepointFolderItem.Title + "/");
IntegrationConfigDataProvider.SaveToItem(integrationConfigData, targetIntegrationItem);
}
public static ItemMock AsConfigurationItem(
this ItemMock item,
IntegrationConfigData configData = null,
string guidValue = "",
bool isIntegrationValue = true)
{
return
(item
.WithIntegrationFields(guidValue, isIntegrationValue)
.WithTemplate(TemplateIDs.IntegrationConfig)
.PutConfigDataToCache(configData));
}
public static ItemMock CreateConfigurationFolder(
this Database database,
string guidValue = "",
bool isIntegrationValue = true,
IntegrationConfigData configData = null)
{
var parent = database.CreateConfigurationItem(string.Empty, isIntegrationValue, configData);
return
(new ItemMock(ID.NewID, database).WithIntegrationFields(guidValue, isIntegrationValue)
.WithTemplate(TemplateIDs.IntegrationFolder)
.WithParent(parent)
.PutConfigDataToCache(configData));
}
protected bool UpdateIntegrationConfigData(Item item)
{
IntegrationConfigData integrationData = null;
try
{
integrationData = IntegrationConfigDataProvider.GetFromItem(item);
if (integrationData == null)
{
return(true);
}
var context = SpContextProviderBase.Instance.CreateDataContext(integrationData);
string listId;
listId = BaseList.GetList(integrationData.Web, integrationData.List, context).ID;
Assert.IsNotNullOrEmpty(listId, "listId");
if (integrationData.List == listId)
{
return(true);
}
integrationData.List = listId;
IntegrationConfigDataProvider.SaveToItem(integrationData, item);
IntegrationCache.RemoveIntegrationConfigData(item.ID);
return(true);
}
catch (Exception exception)
{
var errorMessage = new StringBuilder("Updating integration config data has been failed.");
errorMessage.AppendLine(string.Format("Integration config item: {0}", item.ID));
if (integrationData != null)
{
errorMessage.AppendLine(string.Format("SharePoint list: {0}{1}{2}", integrationData.Server.Trim('/'), StringUtil.EnsurePrefix('/', StringUtil.EnsurePostfix('/', integrationData.Web)), integrationData.List.Trim('/')));
}
Log.Error(errorMessage.ToString(), exception, this);
return(false);
}
}
public void should_fill_data_context_from_config_data()
{
// Arrange
var provider = new SpContextProvider();
var configData = new IntegrationConfigData(SharepointServerUrl, "list", "template")
{
ConnectionConfiguration = ConnectionConfiguration,
};
configData.SetCredentials("UserName", "Password");
// Act
var context = provider.CreateDataContext(configData);
// Assert
context.ConnectionConfiguration.Should().Be(configData.ConnectionConfiguration);
context.Credentials.Should().Be(configData.Credentials);
context.Url.Should().BeEquivalentTo(configData.Server);
}
private SynchronizeTreeArgs CreateArgs(
TestHelper.Items sitecoreItems,
TestHelper.Items sharepointItems,
bool isBidirectional = true)
{
var configData = new IntegrationConfigData("server", "list", "templateID")
{
BidirectionalLink = isBidirectional
};
var args = new SynchronizeTreeArgs
{
IntegrationItems = TestHelper.CreateSitecoreItemsList(sitecoreItems),
SharepointItemList = TestHelper.CreateSharepointItemsList(sharepointItems),
Context = new SynchContext(new ItemMock().AsConfigurationItem(configData))
};
return(args);
}
public void should_return_all_list_items()
{
// Arrange
var dataContext = Substitute.For <SpContext>();
var list = Substitute.For <BaseList>(new EntityValues(), dataContext, new Uri("http://empty"));
var itemCollection = new MyItemCollection(dataContext, list, new ItemsRetrievingOptions());
var listItems = new List <BaseItem>
{
new BaseItem(new EntityProperties(), list, dataContext),
new BaseItem(new EntityProperties(), list, dataContext),
new BaseItem(new EntityProperties(), list, dataContext)
};
itemCollection.Items = listItems;
// We have to make these methods as virtual in the BaseList class:
list.GetItems(Arg.Any <ItemsRetrievingOptions>()).Returns(itemCollection);
var configData = new IntegrationConfigData("server", "list", "templateID");
var args = new SynchronizeTreeArgs
{
Context = this.CreateSynchContext(configData)
};
var context = Substitute.For <SpContext>();
this.sharepointContextProvider.CreateDataContext(configData).Returns(context);
this.sharepointListProvider.GetList(configData.Web, configData.List, context).Returns(list);
// Act
this.processor.Process(args);
// Assert
args.SharepointItemList.Should().BeEquivalentTo(listItems);
}
protected ObjectModel.Entities.Collections.ItemCollection GetSubItems([NotNull] BaseList list, [NotNull] IntegrationConfigData integrationConfigData)
{
Assert.ArgumentNotNull(list, "list");
Assert.ArgumentNotNull(integrationConfigData, "integrationConfigData");
var itemsOptions = new ItemsRetrievingOptions
{
Folder = integrationConfigData.Folder,
ViewName = integrationConfigData.View,
ItemLimit = integrationConfigData.ItemLimit
};
return(list.GetItems(itemsOptions));
}
/// <summary>Creates data context.</summary> /// <param name="integrationConfigData">The integration config data.</param> /// <returns>The <see cref="SpContext"/>.</returns> public abstract SpContext CreateDataContext(IntegrationConfigData integrationConfigData);
/// <summary>
/// Add specified integration configuration data to the Cache.
/// </summary>
/// <param name="itemId">
/// The item id.
/// </param>
/// <param name="integrationConfigData">
/// The info.
/// </param>
/// <param name="expiredInSeconds">
/// The expired in seconds.
/// </param>
public static void AddIntegrationConfigData(ID itemId, IntegrationConfigData integrationConfigData, ulong expiredInSeconds)
{
Instance.DoAddIntegrationConfigData(itemId, integrationConfigData, expiredInSeconds);
}
