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