protected override void InternalDeployWebModel(ProvisionServiceContext context)
{
var clientContext = context.Context as ClientContext;
var model = context.Model;
ModelService.DeployModel(WebModelHost.FromClientContext(clientContext), model);
}
/// <summary>
/// Deploys and validates target web model.
/// </summary>
/// <param name="model"></param>
public override void DeployWebModel(ModelNode model)
{
foreach (var webUrl in WebUrls)
{
Trace.WriteLine(string.Format("[INF] Running on web: [{0}]", webUrl));
for (var provisionGeneration = 0;
provisionGeneration < ProvisionGenerationCount;
provisionGeneration++)
{
WithO365Context(webUrl, context =>
{
if (EnableDefinitionProvision)
{
_provisionService.DeployModel(WebModelHost.FromClientContext(context), model);
}
if (EnableDefinitionValidation)
{
_validationService.DeployModel(WebModelHost.FromClientContext(context), model);
}
});
}
}
}
private static void ProcessNewPageDefaultSettings(
WebModelHost webModelHost,
PublishingWeb publishingWeb,
PageLayoutAndSiteTemplateSettingsDefinition definition,
List <ListItem> pageLayouts)
{
var web = publishingWeb.Web;
var context = web.Context;
if (definition.InheritDefaultPageLayout.HasValue && definition.InheritDefaultPageLayout.Value)
{
SetPropertyBagValue(web, "__DefaultPageLayout", "__inherit");
}
else if (definition.UseDefinedDefaultPageLayout.HasValue && definition.UseDefinedDefaultPageLayout.Value)
{
var selectedLayoutName = definition.DefinedDefaultPageLayout;
var targetLayout = pageLayouts.FirstOrDefault(t => t["FileLeafRef"].ToString().ToUpper() == selectedLayoutName.ToUpper());
if (targetLayout != null)
{
var resultString = CreateLayoutXmlString(targetLayout);
SetPropertyBagValue(web, "__DefaultPageLayout", resultString);
}
}
}
protected WebNavigationSettings GetWebNavigationSettings(WebModelHost webModelHost, WebNavigationSettingsDefinition navigationModel)
{
var web = webModelHost.HostWeb;
var thisWebNavSettings = new WebNavigationSettings(web);
return(thisWebNavSettings);
}
/// <summary>
/// Deploys and validates target web model.
/// </summary>
/// <param name="model"></param>
public override void DeployWebModel(ModelNode model)
{
if (RandomBalancedUrls.Count > 0)
{
var url = RandomBalancedUrls[rnd.Next(0, RandomBalancedUrls.Count)];
WebOnUrl(model, url);
}
else
{
foreach (var webUrl in WebUrls)
{
ContainerTraceUtils.WriteLine(string.Format("[INF] Running on web: [{0}]", webUrl));
for (var provisionGeneration = 0;
provisionGeneration < ProvisionGenerationCount;
provisionGeneration++)
{
WithO365Context(webUrl, context =>
{
if (EnableDefinitionProvision)
{
_provisionService.DeployModel(WebModelHost.FromClientContext(context), model);
}
if (EnableDefinitionValidation)
{
_validationService.DeployModel(WebModelHost.FromClientContext(context), model);
}
});
}
}
}
}
private void DeployDefinition(object modelHost, WebModelHost webModelHost, PageLayoutAndSiteTemplateSettingsDefinition definition)
{
var web = webModelHost.HostWeb;
var publishingWeb = PublishingWeb.GetPublishingWeb(web);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = web,
ObjectType = typeof(SPWeb),
ObjectDefinition = definition,
ModelHost = modelHost
});
ProcessWebTemplateSettings(publishingWeb, definition);
ProcessPageLayoutSettings(publishingWeb, definition);
ProcessNewPageDefaultSettings(publishingWeb, definition);
ProcessConverBlankSpacesIntoHyphenSetting(publishingWeb, definition);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = web,
ObjectType = typeof(SPWeb),
ObjectDefinition = definition,
ModelHost = modelHost
});
publishingWeb.Update();
}
/// <summary>
/// Deploys and validates target web model.
/// </summary>
/// <param name="model"></param>
public override void DeployWebModel(ModelNode model)
{
if (!WebUrls.Any())
{
throw new SPMeta2Exception("WebUrls is empty");
}
foreach (var webUrl in WebUrls)
{
ContainerTraceUtils.WriteLine(string.Format("[INF] Running on web: [{0}]", webUrl));
for (var provisionGeneration = 0;
provisionGeneration < ProvisionGenerationCount;
provisionGeneration++)
{
WithO365Context(webUrl, context =>
{
if (EnableDefinitionProvision)
{
_provisionService.DeployModel(WebModelHost.FromClientContext(context), model);
}
if (EnableDefinitionValidation)
{
_validationService.DeployModel(WebModelHost.FromClientContext(context), model);
}
});
}
}
}
public override void WithResolvingModelHost(ModelHostResolveContext modelHostContext)
{
var modelHost = modelHostContext.ModelHost;
var model = modelHostContext.Model;
var childModelType = modelHostContext.ChildModelType;
var action = modelHostContext.Action;
var quickLaunchNode = model as NavigationNodeDefinitionBase;
if (modelHost is WebModelHost)
{
CurrentWebModelHost = modelHost as WebModelHost;
var webModelHost = modelHost.WithAssertAndCast <WebModelHost>("modelHost", value => value.RequireNotNull());
var currentNode = EnsureRootNavigationNode(webModelHost, quickLaunchNode);
action(currentNode);
}
else if (modelHost is SPNavigationNode)
{
var node = modelHost as SPNavigationNode;
var currentNode = EnsurehNavigationNode(node, quickLaunchNode);
action(currentNode);
}
else
{
action(modelHost);
}
}
public override void DeployWebModel(ModelNode model)
{
if (!WebUrls.Any())
{
throw new SPMeta2Exception("WebUrls is empty");
}
foreach (var webUrl in WebUrls)
{
//var webUrl = GetTargetSiteCollectionUrl();
ContainerTraceUtils.WriteLine(string.Format("[INF] Running on web: [{0}]", webUrl));
for (var provisionGeneration = 0; provisionGeneration < ProvisionGenerationCount; provisionGeneration++)
{
WithSSOMSiteAndWebContext(webUrl, (site, web) =>
{
if (EnableDefinitionProvision)
{
_provisionService.DeployModel(WebModelHost.FromWeb(web), model);
}
if (EnableDefinitionValidation)
{
_validationService.DeployModel(WebModelHost.FromWeb(web), model);
}
});
}
}
}
public override void DeployWebModel(ModelNode model)
{
//foreach (var webUrl in WebUrls)
// {
var webUrl = GetTargetSiteCollectionUrl();
Trace.WriteLine(string.Format("[INF] Running on web: [{0}]", webUrl));
for (var provisionGeneration = 0; provisionGeneration < ProvisionGenerationCount; provisionGeneration++)
{
WithSSOMSiteAndWebContext(webUrl, (site, web) =>
{
if (EnableDefinitionProvision)
{
_provisionService.DeployModel(WebModelHost.FromWeb(web), model);
}
if (EnableDefinitionValidation)
{
_validationService.DeployModel(WebModelHost.FromWeb(web), model);
}
});
}
//}
}
public override void WithResolvingModelHost(object modelHost, DefinitionBase model, Type childModelType, Action <object> action)
{
var quickLaunchNode = model as NavigationNodeDefinitionBase;
if (modelHost is WebModelHost)
{
CurrentWebModelHost = modelHost as WebModelHost;
var webModelHost = modelHost.WithAssertAndCast <WebModelHost>("modelHost", value => value.RequireNotNull());
var currentNode = EnsureRootNavigationNode(webModelHost, quickLaunchNode);
action(currentNode);
}
else if (modelHost is SPNavigationNode)
{
var node = modelHost as SPNavigationNode;
var currentNode = EnsurehNavigationNode(node, quickLaunchNode);
action(currentNode);
}
else
{
action(modelHost);
}
}
protected override void InternalDeployWebModel(ProvisionServiceContext context)
{
var web = context.Context as SPWeb;
var model = context.Model;
ModelService.DeployModel(WebModelHost.FromWeb(web), model);
}
private void WebOnUrl(ModelNode model, string webUrl)
{
ContainerTraceUtils.WriteLine(string.Format("[INF] Running on web: [{0}]", webUrl));
WithO365Context(webUrl, context =>
{
for (var provisionGeneration = 0;
provisionGeneration < ProvisionGenerationCount;
provisionGeneration++)
{
if (EnableDefinitionProvision)
{
if (OnBeforeDeployModel != null)
{
OnBeforeDeployModel(_provisionService, model);
}
_provisionService.DeployModel(WebModelHost.FromClientContext(context), model);
if (OnAfterDeployModel != null)
{
OnAfterDeployModel(_provisionService, model);
}
}
if (EnableDefinitionValidation)
{
_validationService.DeployModel(WebModelHost.FromClientContext(context), model);
}
}
});
}
public override void DeployWebModel(ModelNode model)
{
WithSSOMContext((site, web) =>
{
_provisionService.DeployModel(WebModelHost.FromWeb(web), model);
_validationService.DeployModel(WebModelHost.FromWeb(web), model);
});
}
/// <summary>
/// A shortcut for incremental provision
/// Sets incremental provision mode with IncrementalProvisionConfig.AutoDetectSharePointPersistenceStorage = true
/// Once done, reverts back to default provision mode
/// Callback on IncrementalProvisionConfig makes it easy to configure IncrementalProvisionConfig instance
/// </summary>
public static void DeployWebModelIncrementally(this SSOMProvisionService modelHost,
SPWeb web,
ModelNode model,
string incrementalModelId,
Action <IncrementalProvisionConfig> config)
{
modelHost.DeployModelIncrementally(WebModelHost.FromWeb(web), model, incrementalModelId, config);
}
private void DeployWebWorkflowAssociationDefinition(WebModelHost modelHost, Microsoft.SharePoint.SPWeb web, WorkflowAssociationDefinition definition)
{
var existingWorkflowAssotiation = FindExistringWorkflowAssotiation(modelHost, definition);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = existingWorkflowAssotiation,
ObjectType = typeof(SPWorkflowAssociation),
ObjectDefinition = definition,
ModelHost = modelHost
});
bool isNew = false;
if (existingWorkflowAssotiation == null)
{
var workflowTemplate = GetWorkflowTemplate(modelHost, definition);
if (workflowTemplate == null)
{
throw new SPMeta2Exception(
string.Format("Cannot find workflow template by definition:[{0}]", definition));
}
existingWorkflowAssotiation = SPWorkflowAssociation.CreateListAssociation(workflowTemplate,
definition.Name,
web.Lists[definition.TaskListTitle],
web.Lists[definition.HistoryListTitle]);
isNew = true;
}
MapProperties(definition, existingWorkflowAssotiation);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = existingWorkflowAssotiation,
ObjectType = typeof(SPWorkflowAssociation),
ObjectDefinition = definition,
ModelHost = modelHost
});
if (isNew)
{
web.WorkflowAssociations.Add(existingWorkflowAssotiation);
web.Update();
}
else
{
web.WorkflowAssociations.Update(existingWorkflowAssotiation);
}
}
public override void WithResolvingModelHost(ModelHostResolveContext modelHostContext)
{
var modelHost = modelHostContext.ModelHost;
var model = modelHostContext.Model;
var childModelType = modelHostContext.ChildModelType;
var action = modelHostContext.Action;
var parentWeb = ExtractWeb(modelHost);
var hostclientContext = ExtractHostClientContext(modelHost);
var hostSite = ExtractHostSite(modelHost);
var webModel = model.WithAssertAndCast <WebDefinition>("model", value => value.RequireNotNull());
var context = parentWeb.Context;
context.Load(parentWeb, w => w.Url);
//context.Load(parentWeb, w => w.RootFolder);
context.Load(parentWeb, w => w.ServerRelativeUrl);
context.ExecuteQueryWithTrace();
var currentWebUrl = GetCurrentWebUrl(context, parentWeb, webModel);
var currentWeb = GetExistingWeb(hostSite, parentWeb, currentWebUrl);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = modelHostContext.ModelNode,
Model = null,
EventType = ModelEventType.OnModelHostResolving,
Object = parentWeb,
ObjectType = typeof(Web),
ObjectDefinition = model,
ModelHost = modelHost
});
var tmpWebModelHost = new WebModelHost
{
HostClientContext = hostclientContext,
HostSite = hostSite,
HostWeb = currentWeb
};
action(tmpWebModelHost);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = modelHostContext.ModelNode,
Model = null,
EventType = ModelEventType.OnModelHostResolved,
Object = parentWeb,
ObjectType = typeof(Web),
ObjectDefinition = model,
ModelHost = modelHost
});
currentWeb.Update();
context.ExecuteQueryWithTrace();
}
protected NavigationNode GetRootNavigationNode(
WebModelHost webModelHost,
NavigationNodeDefinitionBase quickLaunchModel)
{
NavigationNodeCollection quickLaunch = null;
var result = GetRootNavigationNode(webModelHost, quickLaunchModel, out quickLaunch);
return(result);
}
public static void DeployListModel(this CSOMProvisionService modelHost, ClientContext context, List list, ModelNode model)
{
var listHost = ModelHostBase.Inherit <ListModelHost>(WebModelHost.FromClientContext(context), h =>
{
h.HostList = list;
});
modelHost.DeployModel(listHost, model);
}
public static void DeployListModel(this SSOMProvisionService modelHost, SPList list, ModelNode model)
{
var listHost = ModelHostBase.Inherit <ListModelHost>(WebModelHost.FromWeb(list.ParentWeb), h =>
{
h.HostList = list;
});
modelHost.DeployModel(listHost, model);
}
private NavigationNode EnsureRootQuickLaunchNavigationNode(
WebModelHost webModelHost,
QuickLaunchNavigationNodeDefinition quickLaunchModel)
{
NavigationNodeCollection quickLaunch = null;
var context = webModelHost.HostWeb.Context;
var existingNode = GetRootNavigationNode(webModelHost, quickLaunchModel, out quickLaunch);
var previousNode = quickLaunch.Count > 0 ? quickLaunch.Last() : null;
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = existingNode,
ObjectType = typeof(NavigationNode),
ObjectDefinition = quickLaunchModel,
ModelHost = webModelHost
});
if (existingNode == null)
{
existingNode = quickLaunch.Add(new NavigationNodeCreationInformation
{
Title = quickLaunchModel.Title,
IsExternal = quickLaunchModel.IsExternal,
Url = quickLaunchModel.Url,
PreviousNode = previousNode
});
context.ExecuteQuery();
}
existingNode.Title = quickLaunchModel.Title;
existingNode.Url = quickLaunchModel.Url;
existingNode.IsVisible = quickLaunchModel.IsVisible;
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = existingNode,
ObjectType = typeof(NavigationNode),
ObjectDefinition = quickLaunchModel,
ModelHost = webModelHost
});
existingNode.Update();
context.ExecuteQuery();
return(existingNode);
}
protected virtual SPAppPrincipal FindExistingAppPrincipal(WebModelHost webHost,
AppPrincipalDefinition appPrincipalModel)
{
var appPrincipalManager = SPAppPrincipalManager.GetManager(webHost.HostWeb);
var appPrincipalProvider = SPAppPrincipalIdentityProvider.External;
var appPrincipalName = SPAppPrincipalName.CreateFromAppPrincipalIdentifier(appPrincipalModel.AppId);
return(appPrincipalManager.LookupAppPrincipal(appPrincipalProvider, appPrincipalName));
}
protected FeatureCollection LoadWebFeatures(WebModelHost webModelHost)
{
var web = webModelHost.HostWeb;
var context = web.Context;
context.Load(web, w => w.Features);
context.ExecuteQuery();
return(web.Features);
}
private Field DeployWebField(WebModelHost webModelHost, FieldDefinition fieldModel)
{
TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Deploying web field");
var web = webModelHost.HostWeb;
var context = web.Context;
var field = GetField(webModelHost, fieldModel);
return(EnsureField(context, field, web.Fields, fieldModel));
}
public override void DeployWebModel(ModelNode model)
{
WithO365Context(context =>
{
_provisionService.DeployModel(WebModelHost.FromClientContext(context), model);
if (EnableDefinitionValidation)
{
_validationService.DeployModel(WebModelHost.FromClientContext(context), model);
}
});
}
protected ClientObjectList <AppInstance> FindExistingApps(WebModelHost webHost, AppDefinition appModel)
{
TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "FindExistingApps() - finding app by productId: [{0}]", appModel.ProductId);
var context = webHost.HostWeb.Context;
var result = webHost.HostWeb.GetAppInstancesByProductId(appModel.ProductId);
context.Load(result);
context.ExecuteQueryWithTrace();
return(result);
}
protected WebNavigationSettings GetWebNavigationSettings(WebModelHost webModelHost, WebNavigationSettingsDefinition navigationModel)
{
var web = webModelHost.HostWeb;
var context = web.Context;
var thisWebNavSettings = new WebNavigationSettings(context, web);
context.Load(thisWebNavSettings);
context.ExecuteQueryWithTrace();
return(thisWebNavSettings);
}
private SPNavigationNode EnsureRootNavigationNode(WebModelHost webModelHost, NavigationNodeDefinitionBase rootNode)
{
var web = webModelHost.HostWeb;
var quickLaunch = GetNavigationNodeCollection(web);
var existingNode = LookupNavigationNode(quickLaunch, rootNode);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioning,
Object = existingNode,
ObjectType = typeof(SPNavigationNode),
ObjectDefinition = rootNode,
ModelHost = webModelHost
});
if (existingNode == null)
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingNewObject, "Processing new navigation node");
existingNode = new SPNavigationNode(rootNode.Title, ResolveTokenizedUrl(webModelHost, rootNode), rootNode.IsExternal);
quickLaunch.AddAsLast(existingNode);
}
else
{
TraceService.Information((int)LogEventId.ModelProvisionProcessingExistingObject, "Processing existing navigation node");
}
existingNode.Title = rootNode.Title;
existingNode.Url = ResolveTokenizedUrl(webModelHost, rootNode);
existingNode.IsVisible = rootNode.IsVisible;
ProcessProperties(existingNode, rootNode);
ProcessLocalization(existingNode, rootNode);
InvokeOnModelEvent(this, new ModelEventArgs
{
CurrentModelNode = null,
Model = null,
EventType = ModelEventType.OnProvisioned,
Object = existingNode,
ObjectType = typeof(SPNavigationNode),
ObjectDefinition = rootNode,
ModelHost = webModelHost
});
existingNode.Update();
return(existingNode);
}
public override void DeployListModel(ModelNode model)
{
foreach (var webUrl in WebUrls)
{
ContainerTraceUtils.WriteLine(string.Format("[INF] Running on web: [{0}]", webUrl));
WithCSOMContext(webUrl, context =>
{
for (var provisionGeneration = 0;
provisionGeneration < ProvisionGenerationCount;
provisionGeneration++)
{
List list = null;
try
{
list = context.Web.QueryAndGetListByTitle("Site Pages");
}
catch (Exception ex) { }
if (list == null)
{
try
{
list = context.Web.QueryAndGetListByTitle("Pages");
}
catch (Exception ex) { }
}
if (list == null)
{
throw new SPMeta2Exception("Cannot find host list");
}
if (EnableDefinitionProvision)
{
_provisionService.DeployListModel(context, list, model);
}
if (EnableDefinitionValidation)
{
var listHost = ModelHostBase.Inherit <ListModelHost>(WebModelHost.FromClientContext(context), h =>
{
h.HostList = list;
});
_validationService.DeployModel(listHost, model);
}
}
});
}
}
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);
}
