protected override void ProcessWebpartProperties(WebPart webpartInstance, WebPartDefinition webpartModel)
{
base.ProcessWebpartProperties(webpartInstance, webpartModel);
var typedWebpart = webpartInstance.WithAssertAndCast <PageViewerWebPart>("webpartInstance", value => value.RequireNotNull());
var definition = webpartModel.WithAssertAndCast <PageViewerWebPartDefinition>("webpartModel", value => value.RequireNotNull());
if (!string.IsNullOrEmpty(definition.ContentLink))
{
var contentLinkValue = definition.ContentLink ?? string.Empty;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Original contentLinkValue: [{0}]", contentLinkValue);
contentLinkValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = contentLinkValue,
Context = CurrentHost.PageListItem.Web
}).Value;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Token replaced contentLinkValue: [{0}]", contentLinkValue);
typedWebpart.ContentLink = contentLinkValue;
}
if (!string.IsNullOrEmpty(definition.SourceType))
{
typedWebpart.SourceType = (PathPattern)Enum.Parse(typeof(PathPattern), definition.SourceType);
}
}
protected override string GetWebpartXmlDefinition(
ListItemModelHost listItemModelHost,
WebPartDefinitionBase webPartModel)
{
var typedDefinition = webPartModel.WithAssertAndCast <SilverlightWebPartDefinition>("model", value => value.RequireNotNull());
var wpXml = WebpartXmlExtensions.LoadWebpartXmlDocument(this.ProcessCommonWebpartProperties(BuiltInWebPartTemplates.SilverlightWebPart, webPartModel));
if (!string.IsNullOrEmpty(typedDefinition.Url))
{
var linkValue = typedDefinition.Url;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Original Url: [{0}]", linkValue);
linkValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = linkValue,
Context = listItemModelHost
}).Value;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Token replaced Url: [{0}]", linkValue);
wpXml.SetOrUpdateProperty("Url", linkValue);
}
if (!string.IsNullOrEmpty(typedDefinition.CustomInitParameters))
{
wpXml.SetOrUpdateProperty("CustomInitParameters", typedDefinition.CustomInitParameters);
}
return(wpXml.ToString());
}
protected override string GetWebpartXmlDefinition(ListItemModelHost listItemModelHost, WebPartDefinitionBase webPartModel)
{
var definition = webPartModel.WithAssertAndCast <PageViewerWebPartDefinition>("model", value => value.RequireNotNull());
var wpXml = WebpartXmlExtensions
.LoadWebpartXmlDocument(BuiltInWebPartTemplates.PageViewerWebPart);
if (!string.IsNullOrEmpty(definition.ContentLink))
{
var contentLinkValue = definition.ContentLink ?? string.Empty;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Original contentLinkValue: [{0}]", contentLinkValue);
contentLinkValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = contentLinkValue,
Context = listItemModelHost.HostClientContext
}).Value;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Token replaced contentLinkValue: [{0}]", contentLinkValue);
wpXml.SetOrUpdatePageViewerWebPartProperty("ContentLink", contentLinkValue);
}
if (!string.IsNullOrEmpty(definition.SourceType))
{
wpXml.SetOrUpdatePageViewerWebPartProperty("SourceType", definition.SourceType);
}
return(wpXml.ToString());
}
public ITestDataService Create(string platform)
{
var traceService = new FileTraceService {
IsDebugEnabled = true
};
var tokenReplacementService = new TokenReplacementService(traceService);
switch (platform.ToLower())
{
case SUPPORTED_DATABASES.SQLSERVER:
{
return(new SqlServerTestDataService(new SqlServerDataService(traceService), tokenReplacementService));
}
case SUPPORTED_DATABASES.POSTGRESQL:
{
return(new PostgreSqlTestDataService(new PostgreSqlDataService(traceService), tokenReplacementService));
}
case SUPPORTED_DATABASES.MYSQL:
{
return(new MySqlTestDataService(new MySqlDataService(traceService), tokenReplacementService));
}
default:
throw new NotSupportedException($"The target database platform {platform} is not supported or plugins location was not correctly configured. " +
$"See WIKI for supported database platforms and usage guide.");
}
}
protected override string GetWebpartXmlDefinition(ListItemModelHost listItemModelHost, WebPartDefinitionBase webPartModel)
{
var typedModel = webPartModel.WithAssertAndCast <ContentEditorWebPartDefinition>("model", value => value.RequireNotNull());
var wpXml = WebpartXmlExtensions.LoadWebpartXmlDocument(BuiltInWebPartTemplates.ContentEditorWebPart);
if (!string.IsNullOrEmpty(typedModel.Content))
{
wpXml.SetOrUpdateContentEditorWebPartProperty("Content", typedModel.Content, true);
}
if (!string.IsNullOrEmpty(typedModel.ContentLink))
{
var urlValue = typedModel.ContentLink ?? string.Empty;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Original value: [{0}]", urlValue);
urlValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = urlValue,
Context = listItemModelHost
}).Value;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Token replaced value: [{0}]", urlValue);
wpXml.SetOrUpdateContentEditorWebPartProperty("ContentLink", urlValue);
}
return(wpXml.ToString());
}
protected override void ProcessWebpartProperties(WebPart webpartInstance, WebPartDefinition webpartModel)
{
base.ProcessWebpartProperties(webpartInstance, webpartModel);
var typedWebpart = webpartInstance.WithAssertAndCast <SilverlightWebPart>("webpartInstance", value => value.RequireNotNull());
var typedDefinition = webpartModel.WithAssertAndCast <SilverlightWebPartDefinition>("webpartModel", value => value.RequireNotNull());
if (!string.IsNullOrEmpty(typedDefinition.Url))
{
var linkValue = typedDefinition.Url;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Original Url: [{0}]", linkValue);
linkValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = linkValue,
Context = CurrentHost.HostFile.Web
}).Value;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Token replaced Url: [{0}]", linkValue);
typedWebpart.Url = linkValue;
}
if (!string.IsNullOrEmpty(typedDefinition.CustomInitParameters))
{
typedWebpart.CustomInitParameters = typedDefinition.CustomInitParameters;
}
}
public SPWeb GetTargetWeb(SPSite site, string webUrl, Guid?webId)
{
if (webId.HasGuidValue())
{
return(site.OpenWeb(webId.Value));
}
else if (!string.IsNullOrEmpty(webUrl))
{
var targetWebUrl = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = webUrl,
Context = site
}).Value;
// server relative URl, always
targetWebUrl = UrlUtility.RemoveStartingSlash(targetWebUrl);
targetWebUrl = "/" + targetWebUrl;
var targetWeb = site.OpenWeb(targetWebUrl);
return(targetWeb);
}
// root web by default
return(site.RootWeb);
}
private void DeployAtSiteLevel(object modelHost, SPSite site, SearchSettingsDefinition definition)
{
var web = site.RootWeb;
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = web,
ObjectType = typeof(SPWeb),
ObjectDefinition = definition,
ModelHost = modelHost
});
if (!string.IsNullOrEmpty(definition.SearchCenterUrl))
{
SetSearchCenterUrlAtSiteLevel(web, definition.SearchCenterUrl);
}
var searchSettings = GetCurrentSearchConfigAtSiteLevel(web);
if (searchSettings != null)
{
if (definition.UseParentResultsPageUrl.HasValue)
{
searchSettings.Inherit = definition.UseParentResultsPageUrl.Value;
}
if (!string.IsNullOrEmpty(definition.UseCustomResultsPageUrl))
{
var url = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Context = web,
Value = definition.UseCustomResultsPageUrl
}).Value;
searchSettings.ResultsPageAddress = url;
}
SetCurrentSearchConfigAtSiteLevel(web, searchSettings);
}
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = web,
ObjectType = typeof(SPWeb),
ObjectDefinition = definition,
ModelHost = modelHost
});
web.Update();
}
public Web GetTargetWeb(Site site, string webUrl, Guid?webId, object replacementObject)
{
var context = site.Context;
if (webId.HasGuidValue())
{
var targetWeb = site.OpenWebById(webId.Value);
context.Load(targetWeb);
context.ExecuteQueryWithTrace();
return(targetWeb);
}
else if (!string.IsNullOrEmpty(webUrl))
{
if (replacementObject == null)
{
throw new ArgumentNullException("replacementObject");
}
//var oldValue = CSOMTokenReplacementService.AllowClientContextAsTokenReplacementContext;
try
{
// restrict, only site / web
// Tokens in LookupWebUrl #1013
// https://github.com/SubPointSolutions/spmeta2/issues/1013
//CSOMTokenReplacementService.AllowClientContextAsTokenReplacementContext = false;
var targetWebUrl = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = webUrl,
Context = replacementObject
}).Value;
// server relative url, ensure / in the beginning
targetWebUrl = UrlUtility.RemoveStartingSlash(targetWebUrl);
targetWebUrl = "/" + targetWebUrl;
var targetWeb = site.OpenWeb(targetWebUrl);
context.Load(targetWeb);
context.ExecuteQueryWithTrace();
return(targetWeb);
}
finally
{
//CSOMTokenReplacementService.AllowClientContextAsTokenReplacementContext = oldValue;
}
}
// root web by default
return(site.RootWeb);
}
public void Test_Missing_Token_Values_Must_Throw_Exception()
{
//arrange
var traceService = new Mock <ITraceService>();
var sqlStatement = @"SELECT 'Ok' ${Token1}, 'Ok' ${Token2}, 'Ok' ${Token3}";
//act and assert
Assert.ThrowsException <YuniqlMigrationException>(() =>
{
var sut = new TokenReplacementService(traceService.Object);
var result = sut.Replace(new List <KeyValuePair <string, string> >(), sqlStatement);
}).Message.Contains("Some tokens were not successfully replaced.").ShouldBeTrue();
}
public void Test_When_No_Tokens_Values_Passed_Do_Nothing()
{
//arrange
var traceService = new Mock <ITraceService>();
var sqlStatement = @"SELECT Column1, Column2, Column3";
//act
var sut = new TokenReplacementService(traceService.Object);
var result = sut.Replace(new List <KeyValuePair <string, string> >(), sqlStatement);
//asset
result.ShouldBe("SELECT Column1, Column2, Column3");
}
protected virtual string ResolveTokenizedUrl(WebModelHost webModelHost, string tokenizedUrl)
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Original Url: [{0}]", tokenizedUrl);
var newUrlValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = tokenizedUrl,
Context = webModelHost.HostWeb
}).Value;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Token replaced Url: [{0}]", newUrlValue);
return(newUrlValue);
}
protected virtual string ResolveTokenizedUrl(CSOMModelHostBase context, string urlValue)
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Original Url: [{0}]", urlValue);
var newUrlValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = urlValue,
Context = context
}).Value;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Token replaced Url: [{0}]", newUrlValue);
return(newUrlValue);
}
protected virtual string ResolveUrlWithTokens(SPWeb web, string url)
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Original url: [{0}]", url);
url = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = url,
Context = web,
IsSiteRelativeUrl = true
}).Value;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Token replaced url: [{0}]", url);
return(url);
}
protected override void ProcessWebpartProperties(WebPart webpartInstance, WebPartDefinition webpartModel)
{
base.ProcessWebpartProperties(webpartInstance, webpartModel);
var typedWebpart = webpartInstance.WithAssertAndCast <SPUserCodeWebPart>("webpartInstance", value => value.RequireNotNull());
var typedModel = webpartModel.WithAssertAndCast <UserCodeWebPartDefinition>("webpartModel", value => value.RequireNotNull());
// TODO
typedWebpart.SolutionId = typedModel.SolutionId;
typedWebpart.AssemblyFullName = typedModel.AssemblyFullName;
typedWebpart.TypeFullName = typedModel.TypeFullName;
foreach (var prop in typedModel.UserCodeProperties)
{
var currentProperty = typedWebpart.Properties
.OfType <SPUserCodeProperty>()
.FirstOrDefault(p => p.Name.ToUpper() == prop.Name.ToUpper());
if (currentProperty == null)
{
currentProperty = new SPUserCodeProperty
{
Name = prop.Name
};
typedWebpart.Properties.Add(currentProperty);
}
if (prop.IsTokenisable.HasValue && prop.IsTokenisable.Value)
{
// Enhance 'UserCodeWebPartDefinition'
// UserCodeProperty should support ~sitecollection/~site tokens #485
var value = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = prop.Value,
Context = CurrentHost.HostFile.Web
}).Value;
currentProperty.Value = value;
}
else
{
currentProperty.Value = prop.Value;
}
}
}
protected virtual string ResolveTokenizedUrl(WebModelHost webModelHost, NavigationNodeDefinitionBase rootNode)
{
var urlValue = rootNode.Url;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Original Url: [{0}]", urlValue);
var newUrlValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = urlValue,
Context = webModelHost.HostWeb
}).Value;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Token replaced Url: [{0}]", newUrlValue);
return(newUrlValue);
}
public Web GetTargetWeb(Site site, string webUrl, Guid?webId)
{
var context = site.Context;
if (webId.HasGuidValue())
{
var targetWeb = site.OpenWebById(webId.Value);
context.Load(targetWeb);
context.ExecuteQueryWithTrace();
return(targetWeb);
}
else if (!string.IsNullOrEmpty(webUrl))
{
var oldValue = CSOMTokenReplacementService.AllowClientContextAsTokenReplacementContext;
try
{
CSOMTokenReplacementService.AllowClientContextAsTokenReplacementContext = true;
var targetWebUrl = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = webUrl,
Context = context
}).Value;
// server relative url, ensure / in the beginning
targetWebUrl = UrlUtility.RemoveStartingSlash(targetWebUrl);
targetWebUrl = "/" + targetWebUrl;
var targetWeb = site.OpenWeb(targetWebUrl);
context.Load(targetWeb);
context.ExecuteQueryWithTrace();
return(targetWeb);
}
finally
{
CSOMTokenReplacementService.AllowClientContextAsTokenReplacementContext = oldValue;
}
}
// root web by default
return(site.RootWeb);
}
public void Test_Replace_Token()
{
//arrange
var traceService = new Mock <ITraceService>();
var sqlStatement = @"SELECT 'Ok' ${Token1}, 'Ok' ${Token2}, 'Ok' ${Token3}";
//act
var sut = new TokenReplacementService(traceService.Object);
var result = sut.Replace(new List <KeyValuePair <string, string> > {
new KeyValuePair <string, string>("Token1", "TokenValue1"),
new KeyValuePair <string, string>("Token2", "TokenValue2"),
new KeyValuePair <string, string>("Token3", "TokenValue3"),
}, sqlStatement);
//asset
result.ShouldBe("SELECT 'Ok' TokenValue1, 'Ok' TokenValue2, 'Ok' TokenValue3");
}
protected void InternalSetSearchCenterUrl(SPWeb web, string url, bool isWebLevel)
{
var propertyBagName = "SRCH_ENH_FTR_URL_SITE";
if (isWebLevel)
{
propertyBagName = "SRCH_ENH_FTR_URL_WEB";
}
if (!string.IsNullOrEmpty(url))
{
url = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Context = web,
Value = url
}).Value;
web.AllProperties[propertyBagName] = url;
}
}
private IMigrationService CreateNonTransactionalMigrationService(IDataService dataService, IBulkImportService bulkImportService)
{
var localVersionService = new LocalVersionService(_traceService);
var tokenReplacementService = new TokenReplacementService(_traceService);
var directoryService = new DirectoryService();
var fileService = new FileService();
var configurationService = new ConfigurationDataService(dataService, _traceService, tokenReplacementService);
var migrationService = new NonTransactionalMigrationService(
localVersionService,
dataService,
bulkImportService,
configurationService,
tokenReplacementService,
directoryService,
fileService,
_traceService);
return(migrationService);
}
public SPWeb GetTargetWeb(SPSite site, string webUrl, Guid?webId)
{
if (webId.HasGuidValue())
{
return(site.OpenWeb(webId.Value));
}
else if (!string.IsNullOrEmpty(webUrl))
{
// Tokens in LookupWebUrl #1013
// https://github.com/SubPointSolutions/spmeta2/issues/1013
// this is a dirty hack, we know that
// passing site / web depending on the current context we are in - site or web level
object replacementContext = site;
if (ModelHost is WebModelHost)
{
replacementContext = (ModelHost as WebModelHost).HostWeb;
}
var targetWebUrl = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = webUrl,
Context = replacementContext
}).Value;
// server relative URl, always
targetWebUrl = UrlUtility.RemoveStartingSlash(targetWebUrl);
targetWebUrl = "/" + targetWebUrl;
var targetWeb = site.OpenWeb(targetWebUrl);
return(targetWeb);
}
// root web by default
return(site.RootWeb);
}
private IMigrationService CreateInternal(IDataService dataService, IBulkImportService bulkImportService)
{
var directoryService = new DirectoryService();
var fileService = new FileService();
var workspaceService = new WorkspaceService(_traceService, directoryService, fileService);
var tokenReplacementService = new TokenReplacementService(_traceService);
var metadataService = new MetadataService(dataService, _traceService, tokenReplacementService);
var environmentService = new EnvironmentService();
var configurationService = new ConfigurationService(environmentService, workspaceService, _traceService);
var migrationService = new MigrationService(
workspaceService,
dataService,
bulkImportService,
metadataService,
tokenReplacementService,
directoryService,
fileService,
_traceService,
configurationService);
return(migrationService);
}
public Web GetTargetWeb(Site site, LookupFieldDefinition definition)
{
var context = site.Context;
if (definition.LookupWebId.HasGuidValue())
{
var targetWeb = site.OpenWebById(definition.LookupWebId.Value);
context.Load(targetWeb);
context.ExecuteQueryWithTrace();
return(targetWeb);
}
else if (!string.IsNullOrEmpty(definition.LookupWebUrl))
{
var targetWebUrl = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = definition.LookupWebUrl,
Context = context
}).Value;
// server relative url, ensure / in the beginning
targetWebUrl = UrlUtility.RemoveStartingSlash(targetWebUrl);
targetWebUrl = "/" + targetWebUrl;
var targetWeb = site.OpenWeb(targetWebUrl);
context.Load(targetWeb);
context.ExecuteQueryWithTrace();
return(targetWeb);
}
// root web by default
return(site.RootWeb);
}
protected override void ProcessWebpartProperties(WebPart webpartInstance, WebPartDefinition webpartModel)
{
base.ProcessWebpartProperties(webpartInstance, webpartModel);
var typedWebpart = webpartInstance.WithAssertAndCast <ContentEditorWebPart>("webpartInstance", value => value.RequireNotNull());
var typedModel = webpartModel.WithAssertAndCast <ContentEditorWebPartDefinition>("webpartModel", value => value.RequireNotNull());
if (!string.IsNullOrEmpty(typedModel.ContentLink))
{
var contentLinkValue = typedModel.ContentLink ?? string.Empty;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Original contentLinkValue: [{0}]",
contentLinkValue);
contentLinkValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = contentLinkValue,
Context = CurrentHost.HostFile.Web
}).Value;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Token replaced contentLinkValue: [{0}]", contentLinkValue);
typedWebpart.ContentLink = contentLinkValue;
}
if (!string.IsNullOrEmpty(typedModel.Content))
{
var xmlDoc = new XmlDocument();
var xmlElement = xmlDoc.CreateElement("ContentElement");
var content = typedModel.Content ?? string.Empty;
xmlElement.InnerText = content;
typedWebpart.Content = xmlElement;
}
}
private void DeployAtSiteLevel(object modelHost, Site site, SearchSettingsDefinition definition)
{
var csomModelHost = modelHost.WithAssertAndCast <CSOMModelHostBase>("modelHost", value => value.RequireNotNull());
var web = site.RootWeb;
var context = web.Context;
context.Load(web);
context.Load(web, w => w.AllProperties);
context.ExecuteQueryWithTrace();
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = web,
ObjectType = typeof(Web),
ObjectDefinition = definition,
ModelHost = modelHost
});
if (!string.IsNullOrEmpty(definition.SearchCenterUrl))
{
SetSearchCenterUrlAtSiteLevel(csomModelHost, web, definition.SearchCenterUrl);
}
var searchSettings = GetCurrentSearchConfigAtSiteLevel(web);
if (searchSettings != null)
{
if (definition.UseParentResultsPageUrl.HasValue)
{
searchSettings.Inherit = definition.UseParentResultsPageUrl.Value;
}
if (!string.IsNullOrEmpty(definition.UseCustomResultsPageUrl))
{
var url = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Context = csomModelHost,
Value = definition.UseCustomResultsPageUrl
}).Value;
searchSettings.ResultsPageAddress = url;
}
SetCurrentSearchConfigAtSiteLevel(csomModelHost, web, searchSettings);
}
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = web,
ObjectType = typeof(Web),
ObjectDefinition = definition,
ModelHost = modelHost
});
web.Update();
context.ExecuteQueryWithTrace();
}
public override void DeployModel(object modelHost, DefinitionBase model)
{
var web = ExtractWeb(modelHost);
var contentTypeModel = model.WithAssertAndCast <ContentTypeDefinition>("model", value => value.RequireNotNull());
var site = web.Site;
var targetWeb = web;
// SPBug, it has to be new SPWen for every content type operation inside feature event handler
using (var tmpWeb = site.OpenWeb(targetWeb.ID))
{
var contentTypeId = new SPContentTypeId(contentTypeModel.GetContentTypeId());
// by ID, by Name
var targetContentType = tmpWeb.ContentTypes[contentTypeId];
if (targetContentType == null)
{
targetContentType = tmpWeb.ContentTypes
.OfType <SPContentType>()
.FirstOrDefault(f => f.Name.ToUpper() == contentTypeModel.Name.ToUpper());
}
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = targetContentType,
ObjectType = typeof(SPContentType),
ObjectDefinition = contentTypeModel,
ModelHost = modelHost
});
if (targetContentType == null)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject, "Processing new content type");
targetContentType = tmpWeb
.ContentTypes
.Add(new SPContentType(contentTypeId, tmpWeb.ContentTypes, contentTypeModel.Name));
}
else
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing content type");
}
targetContentType.Hidden = contentTypeModel.Hidden;
targetContentType.Name = contentTypeModel.Name;
targetContentType.Group = contentTypeModel.Group;
// SPBug, description cannot be null
targetContentType.Description = contentTypeModel.Description ?? string.Empty;
if (!string.IsNullOrEmpty(contentTypeModel.DocumentTemplate))
{
var processedDocumentTemplateUrl = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = contentTypeModel.DocumentTemplate,
Context = tmpWeb
}).Value;
// resource related path
if (!processedDocumentTemplateUrl.Contains('/') &&
!processedDocumentTemplateUrl.Contains('\\'))
{
processedDocumentTemplateUrl = UrlUtility.CombineUrl(new string[] {
targetContentType.ResourceFolder.ServerRelativeUrl,
processedDocumentTemplateUrl
});
}
targetContentType.DocumentTemplate = processedDocumentTemplateUrl;
}
ProcessLocalization(targetContentType, contentTypeModel);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = targetContentType,
ObjectType = typeof(SPContentType),
ObjectDefinition = contentTypeModel,
ModelHost = modelHost
});
TraceService.Information((int)LogEventId.ModelProvisionCoreCall, "Calling currentContentType.Update(true)");
targetContentType.UpdateIncludingSealedAndReadOnly(true);
tmpWeb.Update();
}
}
protected virtual void ProcessWebpartProperties(WebPart instance, WebPartDefinition definition)
{
if (definition.Width.HasValue)
{
instance.Width = new Unit(definition.Width.Value);
}
if (definition.Height.HasValue)
{
instance.Height = new Unit(definition.Height.Value);
}
if (!string.IsNullOrEmpty(definition.ChromeState))
{
instance.ChromeState = (PartChromeState)Enum.Parse(typeof(PartChromeState), definition.ChromeState);
}
if (!string.IsNullOrEmpty(definition.ChromeType))
{
var chromeType = WebPartChromeTypesConvertService.NormilizeValueToPartChromeTypes(definition.ChromeType);
instance.ChromeType = (PartChromeType)Enum.Parse(typeof(PartChromeType), chromeType);
}
if (!string.IsNullOrEmpty(definition.ImportErrorMessage))
{
instance.ImportErrorMessage = definition.ImportErrorMessage;
}
if (!string.IsNullOrEmpty(definition.Description))
{
instance.Description = definition.Description;
}
if (!string.IsNullOrEmpty(definition.TitleIconImageUrl))
{
instance.TitleIconImageUrl = definition.TitleIconImageUrl;
}
if (!string.IsNullOrEmpty(definition.TitleUrl))
{
var urlValue = definition.TitleUrl ?? string.Empty;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Original value: [{0}]",
urlValue);
urlValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = urlValue,
Context = CurrentHost.HostFile.Web
}).Value;
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Token replaced value: [{0}]", urlValue);
instance.TitleUrl = urlValue;
}
if (!string.IsNullOrEmpty(definition.ExportMode))
{
instance.ExportMode = (WebPartExportMode)Enum.Parse(typeof(WebPartExportMode), definition.ExportMode);
}
ProcessWebpartCustomProperties(instance, definition);
ProcessParameterBindings(instance, definition);
}
private void MapListProperties(object modelHost, List list, ListDefinition definition)
{
var csomModelHost = modelHost.WithAssertAndCast <CSOMModelHostBase>("modelHost", value => value.RequireNotNull());
var context = list.Context;
list.Title = definition.Title;
list.Description = definition.Description ?? string.Empty;
list.ContentTypesEnabled = definition.ContentTypesEnabled;
if (definition.Hidden.HasValue)
{
list.Hidden = definition.Hidden.Value;
}
if (!string.IsNullOrEmpty(definition.DraftVersionVisibility))
{
var draftOption = (DraftVisibilityType)Enum.Parse(typeof(DraftVisibilityType), definition.DraftVersionVisibility);
list.DraftVersionVisibility = draftOption;
}
#if !NET35
// IRM
if (definition.IrmEnabled.HasValue)
{
list.IrmEnabled = definition.IrmEnabled.Value;
}
if (definition.IrmExpire.HasValue)
{
list.IrmExpire = definition.IrmExpire.Value;
}
if (definition.IrmReject.HasValue)
{
list.IrmReject = definition.IrmReject.Value;
}
#endif
// the rest
if (definition.EnableAttachments.HasValue)
{
list.EnableAttachments = definition.EnableAttachments.Value;
}
if (definition.EnableFolderCreation.HasValue)
{
list.EnableFolderCreation = definition.EnableFolderCreation.Value;
}
if (definition.EnableMinorVersions.HasValue)
{
list.EnableMinorVersions = definition.EnableMinorVersions.Value;
}
if (definition.EnableModeration.HasValue)
{
list.EnableModeration = definition.EnableModeration.Value;
}
if (definition.EnableVersioning.HasValue)
{
list.EnableVersioning = definition.EnableVersioning.Value;
}
if (definition.ForceCheckout.HasValue)
{
list.ForceCheckout = definition.ForceCheckout.Value;
}
if (definition.Hidden.HasValue)
{
list.Hidden = definition.Hidden.Value;
}
if (definition.NoCrawl.HasValue)
{
list.NoCrawl = definition.NoCrawl.Value;
}
if (definition.OnQuickLaunch.HasValue)
{
list.OnQuickLaunch = definition.OnQuickLaunch.Value;
}
if (definition.MajorVersionLimit.HasValue)
{
if (ReflectionUtils.HasProperty(list, "MajorVersionLimit"))
{
context.AddQuery(new ClientActionSetProperty(list, "MajorVersionLimit", definition.MajorVersionLimit.Value));
}
else
{
TraceService.Critical((int)LogEventId.ModelProvisionCoreCall,
string.Format(
"CSOM runtime doesn't have [{0}] methods support. Update CSOM runtime to a new version. Provision is skipped",
string.Join(", ", new string[] { "MajorVersionLimit" })));
}
}
if (definition.MajorWithMinorVersionsLimit.HasValue)
{
if (ReflectionUtils.HasProperty(list, "MajorWithMinorVersionsLimit"))
{
context.AddQuery(new ClientActionSetProperty(list, "MajorWithMinorVersionsLimit", definition.MajorWithMinorVersionsLimit.Value));
}
else
{
TraceService.Critical((int)LogEventId.ModelProvisionCoreCall,
string.Format(
"CSOM runtime doesn't have [{0}] methods support. Update CSOM runtime to a new version. Provision is skipped",
string.Join(", ", new string[] { "MajorWithMinorVersionsLimit" })));
}
}
if (definition.ReadSecurity.HasValue)
{
if (ReflectionUtils.HasProperty(list, "ReadSecurity"))
{
context.AddQuery(new ClientActionInvokeMethod(list, "ReadSecurity", new object[]
{
definition.ReadSecurity.Value
}));
}
else
{
TraceService.Critical((int)LogEventId.ModelProvisionCoreCall,
"CSOM runtime doesn't have List.ReadSecurity. Update CSOM runtime to a new version. Provision is skipped");
}
}
if (definition.WriteSecurity.HasValue)
{
if (ReflectionUtils.HasProperty(list, "WriteSecurity"))
{
context.AddQuery(new ClientActionInvokeMethod(list, "WriteSecurity", new object[]
{
definition.WriteSecurity.Value
}));
}
else
{
TraceService.Critical((int)LogEventId.ModelProvisionCoreCall,
"CSOM runtime doesn't have List.WriteSecurity. Update CSOM runtime to a new version. Provision is skipped");
}
}
if (!string.IsNullOrEmpty(definition.DocumentTemplateUrl))
{
var urlValue = definition.DocumentTemplateUrl;
urlValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = urlValue,
Context = csomModelHost
}).Value;
if (!urlValue.StartsWith("/") &&
!urlValue.StartsWith("http:") &&
!urlValue.StartsWith("https:"))
{
urlValue = "/" + urlValue;
}
list.DocumentTemplateUrl = urlValue;
}
ProcessLocalization(list, definition);
#if !NET35
if (definition.IndexedRootFolderPropertyKeys.Any())
{
var props = list.RootFolder.Properties;
// may not be there at all
var indexedPropertyValue = props.FieldValues.Keys.Contains("vti_indexedpropertykeys")
? ConvertUtils.ToStringAndTrim(props["vti_indexedpropertykeys"])
: string.Empty;
var currentIndexedProperties = IndexedPropertyUtils.GetDecodeValueForSearchIndexProperty(indexedPropertyValue);
// setup property bag
foreach (var indexedProperty in definition.IndexedRootFolderPropertyKeys)
{
// indexed prop should exist in the prop bag
// otherwise it won't be saved by SharePoint (ILSpy / Refletor to see the logic)
// http://rwcchen.blogspot.com.au/2014/06/sharepoint-2013-indexed-property-keys.html
var propName = indexedProperty.Name;
var propValue = string.IsNullOrEmpty(indexedProperty.Value)
? string.Empty
: indexedProperty.Value;
props[propName] = propValue;
}
// merge and setup indexed prop keys, preserve existing props
foreach (var indexedProperty in definition.IndexedRootFolderPropertyKeys)
{
if (!currentIndexedProperties.Contains(indexedProperty.Name))
{
currentIndexedProperties.Add(indexedProperty.Name);
}
}
props["vti_indexedpropertykeys"] = IndexedPropertyUtils.GetEncodedValueForSearchIndexProperty(currentIndexedProperties);
list.RootFolder.Update();
}
#endif
}
public override void DeployModel(object modelHost, DefinitionBase model)
{
base.DeployModel(modelHost, model);
var listItemModelHost = modelHost.WithAssertAndCast <ListItemModelHost>("modelHost", value => value.RequireNotNull());
var definition = model.WithAssertAndCast <ContentEditorWebPartDefinition>("model", value => value.RequireNotNull());
var pageItem = listItemModelHost.HostListItem;
WithWithExistingWebPart(pageItem, definition, spObject =>
{
var assert = ServiceFactory.AssertService
.NewAssert(model, definition, spObject)
.ShouldNotBeNull(spObject);
if (!string.IsNullOrEmpty(definition.Content))
{
var value = CurrentWebPartXml.GetContentEditorWebPartProperty("Content");
assert.ShouldBeEqual((p, s, d) =>
{
var srcProp = s.GetExpressionValue(m => m.Content);
var isValid = definition.Content == value;
return(new PropertyValidationResult
{
Tag = p.Tag,
Src = srcProp,
Dst = null,
IsValid = isValid
});
});
}
else
{
assert.SkipProperty(m => m.Content, "Content is null or empty. Skipping.");
}
if (!string.IsNullOrEmpty(definition.ContentLink))
{
var value = CurrentWebPartXml.GetContentEditorWebPartProperty("ContentLink");
var defValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Context = listItemModelHost.HostClientContext,
Value = definition.ContentLink
}).Value;
var isValid = defValue.ToUpper() == value.ToUpper();
assert.ShouldBeEqual((p, s, d) =>
{
var srcProp = s.GetExpressionValue(m => m.ContentLink);
return(new PropertyValidationResult
{
Tag = p.Tag,
Src = srcProp,
Dst = null,
IsValid = isValid
});
});
}
else
{
assert.SkipProperty(m => m.ContentLink, "ContentLink is null or empty. Skipping.");
}
});
}
private void MapListProperties(List list, ListDefinition definition)
{
list.Title = definition.Title;
list.Description = definition.Description ?? string.Empty;
list.ContentTypesEnabled = definition.ContentTypesEnabled;
if (definition.Hidden.HasValue)
{
list.Hidden = definition.Hidden.Value;
}
if (!string.IsNullOrEmpty(definition.DraftVersionVisibility))
{
var draftOption = (DraftVisibilityType)Enum.Parse(typeof(DraftVisibilityType), definition.DraftVersionVisibility);
list.DraftVersionVisibility = draftOption;
}
// IRM
if (definition.IrmEnabled.HasValue)
{
list.IrmEnabled = definition.IrmEnabled.Value;
}
if (definition.IrmExpire.HasValue)
{
list.IrmExpire = definition.IrmExpire.Value;
}
if (definition.IrmReject.HasValue)
{
list.IrmReject = definition.IrmReject.Value;
}
// the rest
if (definition.EnableAttachments.HasValue)
{
list.EnableAttachments = definition.EnableAttachments.Value;
}
if (definition.EnableFolderCreation.HasValue)
{
list.EnableFolderCreation = definition.EnableFolderCreation.Value;
}
if (definition.EnableMinorVersions.HasValue)
{
list.EnableMinorVersions = definition.EnableMinorVersions.Value;
}
if (definition.EnableModeration.HasValue)
{
list.EnableModeration = definition.EnableModeration.Value;
}
if (definition.EnableVersioning.HasValue)
{
list.EnableVersioning = definition.EnableVersioning.Value;
}
if (definition.ForceCheckout.HasValue)
{
list.ForceCheckout = definition.ForceCheckout.Value;
}
if (definition.Hidden.HasValue)
{
list.Hidden = definition.Hidden.Value;
}
if (definition.NoCrawl.HasValue)
{
list.NoCrawl = definition.NoCrawl.Value;
}
if (definition.OnQuickLaunch.HasValue)
{
list.OnQuickLaunch = definition.OnQuickLaunch.Value;
}
if (definition.MajorVersionLimit.HasValue)
{
/// CSOM is not supported yet as M2 s build with SP2013 SP1+ assemblies.
/// https://officespdev.uservoice.com/forums/224641-general/suggestions/6016131-majorversionlimit-majorwithminorversionslimit-pr
//list.MajorVersionLimit = definition.MajorVersionLimit.Value;
}
if (definition.MajorWithMinorVersionsLimit.HasValue)
{
/// CSOM is not supported yet as M2 s build with SP2013 SP1+ assemblies.
/// https://officespdev.uservoice.com/forums/224641-general/suggestions/6016131-majorversionlimit-majorwithminorversionslimit-pr
//list.MajorWithMinorVersionsLimit = definition.MajorWithMinorVersionsLimit.Value;
}
if (!string.IsNullOrEmpty(definition.DocumentTemplateUrl))
{
var urlValue = definition.DocumentTemplateUrl;
urlValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
{
Value = urlValue,
Context = list.Context,
}).Value;
if (!urlValue.StartsWith("/") &&
!urlValue.StartsWith("http:") &&
!urlValue.StartsWith("https:"))
{
urlValue = "/" + urlValue;
}
list.DocumentTemplateUrl = urlValue;
}
}
