public void FeatureCollectionRemoveTest() { FeatureCollection collection = new FeatureCollection(this.identifier, this.mockAttributes, this.mockFeatures.Take(1)); collection.Remove(this.mockFeatures[0]).ShouldBeTrue(); collection.Count.ShouldBe(0); collection.Contains(this.mockFeatures[0]).ShouldBeFalse(); Should.Throw <ArgumentNullException>(() => collection.Remove(null)); }
private static bool RemoveFeatureFromWeb(ClientContext userContext, Guid featureDefinitionId) { try { FeatureCollection features = userContext.Web.Features; ClearObjectData(features); userContext.Load(features); userContext.ExecuteQuery(); //DumpFeatures(features, "web"); Feature targetFeature = features.GetById(featureDefinitionId); targetFeature.EnsureProperties(f => f.DefinitionId); if (targetFeature == null || !targetFeature.IsPropertyAvailable("DefinitionId") || targetFeature.ServerObjectIsNull.Value) { Logger.LogInfoMessage(String.Format("Could not delete Feature {0}; feature not found in web.Features", featureDefinitionId.ToString()), false); return(false); } features.Remove(featureDefinitionId, true); // commit the changes userContext.Load(features); userContext.ExecuteQuery(); return(true); } catch (Exception ex) { Logger.LogErrorMessage(String.Format("RemoveFeatureFromWeb() failed for Feature {0} on web {1}; Error={2}", featureDefinitionId.ToString(), userContext.Web.Url, ex.Message), false); return(false); } }
private static bool RemoveFeatureFromSite(ClientContext userContext, Guid featureDefinitionId) { try { FeatureCollection features = userContext.Site.Features; ClearObjectData(features); userContext.Load(features); userContext.ExecuteQuery(); //DumpFeatures(features, "site"); Feature targetFeature = features.GetById(featureDefinitionId); targetFeature.EnsureProperties(f => f.DefinitionId); if (targetFeature == null || !targetFeature.IsPropertyAvailable("DefinitionId") || targetFeature.ServerObjectIsNull.Value) { Logger.LogInfoMessage(String.Format("Could not delete Feature {0}; feature not found in site.Features", featureDefinitionId.ToString()), false); return(false); } features.Remove(featureDefinitionId, true); // commit the changes userContext.Load(features); userContext.ExecuteQuery(); return(true); } catch (Exception ex) { Logger.LogErrorMessage(String.Format("[DeleteMissingFeatures: RemoveFeatureFromSite] failed for Feature {0} on site {1}; Error={2}", featureDefinitionId.ToString(), userContext.Site.Url, ex.Message), true); ExceptionCsv.WriteException(Constants.NotApplicable, userContext.Site.Url, Constants.NotApplicable, "Feature", ex.Message, ex.ToString(), "RemoveFeatureFromSite", ex.GetType().ToString(), String.Format("RemoveFeatureFromSite() failed for Feature {0} on site {1}", featureDefinitionId.ToString(), userContext.Site.Url)); return(false); } }
/// <summary> /// Activates or deactivates a site collection or web scoped feature /// </summary> /// <param name="features">Feature Collection which contains the feature</param> /// <param name="featureID">ID of the feature to activate/deactivate</param> /// <param name="activate">True to activate, false to deactivate the feature</param> /// <param name="scope">Scope of the feature definition</param> /// <param name="pollingIntervalSeconds">The time in seconds between polls for "IsActive"</param> private static void ProcessFeatureInternal(FeatureCollection features, Guid featureID, bool activate, FeatureDefinitionScope scope, int pollingIntervalSeconds = 30) { if (activate) { // Feature enabling can take a long time, especially in case of the publishing feature...so let's make it more reliable bool cancel = false; features.Add(featureID, true, scope); if (pollingIntervalSeconds < 5) { pollingIntervalSeconds = 5; } // Kick off a thread that checks for the feature activation to be complete Task.Run(() => { while (!cancel) { Thread.Sleep(TimeSpan.FromSeconds(pollingIntervalSeconds)); if (!cancel) { cancel = IsFeatureActiveInternal(features, featureID); Log.Info(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_ProcessFeatureInternal_FeatureActivationState, cancel, featureID); } } }); // Kick off a thread that enables the feature Task.Run(() => { try { features.Context.ExecuteQueryRetry(); Log.Info(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_ProcessFeatureInternal_FeatureActive, featureID); } catch (Exception ex) { Log.Info(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_ProcessFeatureInternal_FeatureException, ex.ToString()); } finally { cancel = true; } }).Wait(); } else { try { features.Remove(featureID, false); features.Context.ExecuteQueryRetry(); } catch (Exception ex) { Log.Error(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_FeatureActivationProblem, featureID, ex.Message); } } }
public void DeactivateFeature() { if (this.Definition != null) { FeatureCollection.Remove(this.Definition.Id, true); this.SPObject = null; this.Activated = false; } }
public void RemoveTest() { IFeature feature = new Feature(); FeatureCollection target = new FeatureCollection(new Collection <IFeature> { feature }); const bool expected = true; bool actual = target.Remove(feature); Assert.AreEqual(expected, actual); Assert.AreEqual(0, target.Count); }
private static void DeActivateFeatureInCollection(ClientContext clientContext, GtFeature featureInfo, FeatureCollection featureCollection) { clientContext.Load(featureCollection); clientContext.ExecuteQuery(); if (DoesFeatureExistInCollection(featureCollection, featureInfo.FeatureId)) { Console.WriteLine("Deactivating feature " + featureInfo.FeatureName); featureCollection.Remove(featureInfo.FeatureId, true); clientContext.ExecuteQuery(); } }
public void RemovedInterfaceIsRemoved() { var interfaces = new FeatureCollection(); var thing = new Thing(); interfaces.Add(typeof(IThing), thing); Assert.Equal(interfaces[typeof(IThing)], thing); Assert.True(interfaces.Remove(typeof(IThing))); object thing2; Assert.False(interfaces.TryGetValue(typeof(IThing), out thing2)); }
public void RemovedInterfaceIsRemoved() { var interfaces = new FeatureCollection(); var thing = new Thing(); interfaces.Add(typeof(IThing), thing); Assert.Equal(interfaces[typeof(IThing)], thing); Assert.True(interfaces.Remove(typeof(IThing))); object thing2; Assert.False(interfaces.TryGetValue(typeof(IThing), out thing2)); }
/// <summary> /// Activates or deactivates a site collection or site scoped feature /// </summary> /// <param name="web">Web to be processed - can be root web or sub web</param> /// <param name="featureID">ID of the feature to activate/deactivate</param> /// <param name="activate">True to activate, false to deactivate the feature</param> private static void ProcessFeature(this Web web, Guid featureID, bool activate) { FeatureCollection clientSiteFeatures = web.Features; web.Context.Load(clientSiteFeatures); web.Context.ExecuteQuery(); // The original number of active features...use this to track if the feature activation went OK int oldCount = clientSiteFeatures.Count(); if (activate) { // GetById does not seem to work for site scoped features...if (clientSiteFeatures.GetById(featureID) == null) // FeatureDefinitionScope defines how the features have been deployed. All OOB features are farm deployed clientSiteFeatures.Add(featureID, true, FeatureDefinitionScope.Farm); web.Context.ExecuteQuery(); // retry logic needed to make this more bulletproof :-( web.Context.Load(clientSiteFeatures); web.Context.ExecuteQuery(); int tries = 0; int currentCount = clientSiteFeatures.Count(); while (currentCount <= oldCount && tries < 5) { tries++; clientSiteFeatures.Add(featureID, true, FeatureDefinitionScope.Farm); web.Context.ExecuteQuery(); web.Context.Load(clientSiteFeatures); web.Context.ExecuteQuery(); currentCount = clientSiteFeatures.Count(); } } else { try { clientSiteFeatures.Remove(featureID, false); web.Context.ExecuteQuery(); } catch (Exception ex) { LoggingUtility.LogError(string.Format(MSG_PROBLEM_REMOVING, featureID), ex, EventCategory.Features); } } }
/// <summary> /// Activates or deactivates a site collection or site scoped feature /// </summary> /// <param name="site">Site to be processed</param> /// <param name="featureID">ID of the feature to activate/deactivate</param> /// <param name="activate">True to activate, false to deactivate the feature</param> public static void ProcessFeature(this Site site, Guid featureID, bool activate) { FeatureCollection clientSiteFeatures = site.Features; site.Context.Load(clientSiteFeatures); site.Context.ExecuteQuery(); // The original number of active features...use this to track if the feature activation went OK int oldCount = clientSiteFeatures.Count(); if (activate) { // GetById does not seem to work for site scoped features...if (clientSiteFeatures.GetById(featureID) == null) // FeatureDefinitionScope defines how the features have been deployed. All OOB features are farm deployed clientSiteFeatures.Add(featureID, true, FeatureDefinitionScope.Farm); site.Context.ExecuteQuery(); // retry logic needed to make this more bulletproof :-( site.Context.Load(clientSiteFeatures); site.Context.ExecuteQuery(); int tries = 0; int currentCount = clientSiteFeatures.Count(); while (currentCount <= oldCount && tries < 5) { tries++; clientSiteFeatures.Add(featureID, true, FeatureDefinitionScope.Farm); site.Context.ExecuteQuery(); site.Context.Load(clientSiteFeatures); site.Context.ExecuteQuery(); currentCount = clientSiteFeatures.Count(); } } else { try { clientSiteFeatures.Remove(featureID, false); site.Context.ExecuteQuery(); } catch (Exception ex) { throw; } } }
/// <summary> /// Activates or deactivates a site collection or web scoped feature /// </summary> /// <param name="features">Feature Collection which contains the feature</param> /// <param name="featureID">ID of the feature to activate/deactivate</param> /// <param name="activate">True to activate, false to deactivate the feature</param> private static void ProcessFeatureInternal(FeatureCollection features, Guid featureID, bool activate) { features.Context.Load(features); features.Context.ExecuteQueryRetry(); // The original number of active features...use this to track if the feature activation went OK int oldCount = features.Count(); if (activate) { // GetById does not seem to work for site scoped features...if (clientSiteFeatures.GetById(featureID) == null) // FeatureDefinitionScope defines how the features have been deployed. All OOB features are farm deployed features.Add(featureID, true, FeatureDefinitionScope.Farm); features.Context.ExecuteQueryRetry(); // retry logic needed to make this more bulletproof :-( features.Context.Load(features); features.Context.ExecuteQueryRetry(); int tries = 0; int currentCount = features.Count(); while (currentCount <= oldCount && tries < 5) { tries++; features.Add(featureID, true, FeatureDefinitionScope.Farm); features.Context.ExecuteQueryRetry(); features.Context.Load(features); features.Context.ExecuteQueryRetry(); currentCount = features.Count(); } } else { try { features.Remove(featureID, false); features.Context.ExecuteQueryRetry(); } catch (Exception ex) { Log.Error(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_FeatureActivationProblem, featureID, ex.Message); } } }
void DeActivateMenuItem_Click(object sender, EventArgs e) { Cursor.Current = Cursors.WaitCursor; FeatureCollection.Remove(Definition.Id, true); FeatureCollectionNode nodeCollection = (FeatureCollectionNode)this.Parent; this.ImageIndex = nodeCollection.UnInstalledIndex; this.SelectedImageIndex = nodeCollection.UnInstalledIndex; this.IsInstalled = false; //Program.Window.Explorer.SelectedNode = null; //Program.Window.Explorer.SelectedNode = this; Cursor.Current = Cursors.Default; }
/// <summary> /// Activates or deactivates a site collection or web scoped feature /// </summary> /// <param name="features">Feature Collection which contains the feature</param> /// <param name="featureID">ID of the feature to activate/deactivate</param> /// <param name="activate">True to activate, false to deactivate the feature</param> /// <param name="scope">Scope of the feature definition</param> private static void ProcessFeatureInternal(FeatureCollection features, Guid featureID, bool activate, FeatureDefinitionScope scope) { features.Context.Load(features); features.Context.ExecuteQueryRetry(); // The original number of active features...use this to track if the feature activation went OK int oldCount = features.Count(); if (activate) { // GetById does not seem to work for site scoped features...if (clientSiteFeatures.GetById(featureID) == null) // FeatureDefinitionScope defines how the features have been deployed. All OOB features are farm deployed features.Add(featureID, true, scope); features.Context.ExecuteQueryRetry(); // retry logic needed to make this more bulletproof :-( features.Context.Load(features); features.Context.ExecuteQueryRetry(); int tries = 0; int currentCount = features.Count(); while (currentCount <= oldCount && tries < 5) { tries++; features.Add(featureID, true, scope); features.Context.ExecuteQueryRetry(); features.Context.Load(features); features.Context.ExecuteQueryRetry(); currentCount = features.Count(); } } else { try { features.Remove(featureID, false); features.Context.ExecuteQueryRetry(); } catch (Exception ex) { Log.Error(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_FeatureActivationProblem, featureID, ex.Message); } } }
/// <summary> /// Activates or deactivates a site collection or web scoped feature /// </summary> /// <param name="features">Feature Collection which contains the feature</param> /// <param name="featureID">ID of the feature to activate/deactivate</param> /// <param name="activate">True to activate, false to deactivate the feature</param> /// <param name="scope">Scope of the feature definition</param> /// <param name="pollingIntervalSeconds">The time in seconds between polls for "IsActive"</param> private static async Task ProcessFeatureInternal(FeatureCollection features, Guid featureID, bool activate, FeatureDefinitionScope scope, int pollingIntervalSeconds = 30) { if (activate) { // Feature enabling can take a long time, especially in case of the publishing feature...so let's make it more reliable features.Add(featureID, true, scope); if (pollingIntervalSeconds < 5) { pollingIntervalSeconds = 5; } try { string clientTag = $"{PnPCoreUtilities.PnPCoreVersionTag}:ProcessFeatureInternal"; if (clientTag.Length > 32) { clientTag = clientTag.Substring(0, 32); } features.Context.ClientTag = clientTag; // Don't update this to ExecuteQueryRetry await features.Context.ExecuteQueryAsync(); Log.Info(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_ProcessFeatureInternal_FeatureActive, featureID); } catch (Exception ex) { Log.Info(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_ProcessFeatureInternal_FeatureException, ex.ToString()); // Don't wait for a "feature not found" exception, which is the typical exception we'll see if (ex.HResult != -2146233088) { int retryAttempts = 10; int retryCount = 0; // wait and keep checking if the feature is active while (retryAttempts > retryCount) { Thread.Sleep(TimeSpan.FromSeconds(pollingIntervalSeconds)); if (await IsFeatureActiveInternal(features, featureID, true)) { retryCount = retryAttempts; Log.Info(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_ProcessFeatureInternal_FeatureActivationState, true, featureID); } else { retryCount++; Log.Info(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_ProcessFeatureInternal_FeatureActivationState, false, featureID); } } } } } else { try { features.Remove(featureID, false); await features.Context.ExecuteQueryRetryAsync(); } catch (Exception ex) { Log.Error(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_FeatureActivationProblem, featureID, ex.Message); } } }
private void ProcessFeature( object modelHost, ClientRuntimeContext context, FeatureCollection features, FeatureDefinition featureModel, Microsoft.SharePoint.Client.FeatureDefinitionScope scope) { var currentFeature = GetFeature(features, featureModel); var featureActivated = IsFeatureActivated(features, featureModel); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioning, Object = currentFeature, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); if (!featureActivated) { Feature tmpFeature; if (featureModel.Enable) { tmpFeature = features.Add(featureModel.Id, featureModel.ForceActivate, scope); context.ExecuteQuery(); } else { tmpFeature = GetFeature(features, featureModel); } InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioned, Object = tmpFeature, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); } else { if (featureModel.Enable && featureModel.ForceActivate) { var f = features.Add(featureModel.Id, featureModel.ForceActivate, scope); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioned, Object = f, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); context.ExecuteQuery(); } else if (!featureModel.Enable) { features.Remove(featureModel.Id, featureModel.ForceActivate); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioned, Object = null, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); context.ExecuteQuery(); } else { var tmpFeature = GetFeature(features, featureModel); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioned, Object = tmpFeature, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); } } }
private void ProcessFeature( object modelHost, ClientRuntimeContext context, FeatureCollection features, FeatureDefinition featureModel, Microsoft.SharePoint.Client.FeatureDefinitionScope scope) { var featureId = featureModel.Id; var currentFeature = features.GetById(featureId); features.Context.ExecuteQueryWithTrace(); var featureActivated = IsFeatureActivated(currentFeature); TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Is feature activated: [{0}]", featureActivated); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioning, Object = currentFeature, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); if (!featureActivated) { Feature tmpFeature; if (featureModel.Enable) { TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Enabling feature"); tmpFeature = SafelyActivateWebFeature(context, features, featureModel, scope); } else { TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Fetching feature by ID"); tmpFeature = features.GetById(featureId); features.Context.ExecuteQueryWithTrace(); } InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioned, Object = tmpFeature, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); } else { if (featureModel.Enable && featureModel.ForceActivate) { TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Feature enabled, but ForceActivate = true. Force activating."); var f = SafelyActivateWebFeature(context, features, featureModel, scope); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioned, Object = f, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); } else if (!featureModel.Enable) { TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Removing feature."); features.Remove(featureModel.Id, featureModel.ForceActivate); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioned, Object = null, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); context.ExecuteQueryWithTrace(); } else { TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Fetching feature by ID"); var tmpFeature = features.GetById(featureId); features.Context.ExecuteQueryWithTrace(); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioned, Object = tmpFeature, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); } } }
static void Main(string[] args) { // Request Office365 site from the user string siteUrl = GetSite(); /* Prompt for Credentials */ Console.WriteLine("Enter Credentials for {0}", siteUrl); string userName = GetUserName(); SecureString pwd = GetPassword(); /* End Program if no Credentials */ if (string.IsNullOrEmpty(userName) || (pwd == null)) { return; } // Get access to source site using (var ctx = new ClientContext(siteUrl)) { ctx.AuthenticationMode = ClientAuthenticationMode.Default; ctx.Credentials = new SharePointOnlineCredentials(userName, pwd); Web web = ctx.Web; var allProperties = web.AllProperties; ctx.Load(web); ctx.Load(allProperties); ctx.ExecuteQuery(); UploadAssetsToHostWeb(web); // Actual code for operations // Set the properties accordingly // Notice that these are new properties in 2014 April CU of 15 hive CSOM and July release of MSO CSOM web.AlternateCssUrl = ctx.Web.ServerRelativeUrl + "/SiteAssets/spe-seattle-responsive.css"; // Ensure proper meta tag for viewport is set // Make sure that hardware devices scale CSS definitions properly // More details can be found http://www.n8d.at/blog/how-to-add-viewport-meta-without-editing-the-master-page/ // Check if SEO is enabled and property for custom meta tags exists // This can be enabled on any team site based site collection by enabling // the site collection feature "Publishing Infastructure" // No other publishing related feature needs to be activated // Enable custom meta tags if (allProperties.FieldValues.ContainsKey("seoincludecustommetatagpropertyname")) { allProperties["seoincludecustommetatagpropertyname"] = true.ToString(); } // Add value of custom meta tag if (allProperties.FieldValues.ContainsKey("seocustommetatagpropertyname")) { allProperties["seocustommetatagpropertyname"] = "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1, maximum-scale=1\" />"; } web.Update(); web.Context.ExecuteQuery(); // get features collection on web FeatureCollection features = web.Features; web.Context.Load(features); web.Context.ExecuteQuery(); // disable the 'Mobile Browser View' web feature Guid featureId = new Guid("d95c97f3-e528-4da2-ae9f-32b3535fbb59"); if (Enumerable.Any(features, feature => feature.DefinitionId == featureId)) { features.Remove(new Guid("d95c97f3-e528-4da2-ae9f-32b3535fbb59"), false); web.Context.ExecuteQuery(); } /// Uncomment to clear // Removes alternate CSS URL //web.AlternateCssUrl = ""; // Clear viewport meta tag form SEO settings //if (allProperties.FieldValues.ContainsKey("seoincludecustommetatagpropertyname")) //{ // allProperties["seoincludecustommetatagpropertyname"] = false.ToString(); //} // Add value of custom meta tag //if (allProperties.FieldValues.ContainsKey("seocustommetatagpropertyname")) //{ // allProperties["seocustommetatagpropertyname"] = "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1, maximum-scale=1\" />"; //} //web.Update(); //web.Context.ExecuteQuery(); } }
/// <summary> /// Activates or deactivates a site collection or web scoped feature /// </summary> /// <param name="features">Feature Collection which contains the feature</param> /// <param name="featureID">ID of the feature to activate/deactivate</param> /// <param name="activate">True to activate, false to deactivate the feature</param> /// <param name="scope">Scope of the feature definition</param> /// <param name="pollingIntervalSeconds">The time in seconds between polls for "IsActive"</param> private static void ProcessFeatureInternal(FeatureCollection features, Guid featureID, bool activate, FeatureDefinitionScope scope, int pollingIntervalSeconds = 30) { if (activate) { // Feature enabling can take a long time, especially in case of the publishing feature...so let's make it more reliable features.Add(featureID, true, scope); if (pollingIntervalSeconds < 5) { pollingIntervalSeconds = 5; } try { string clientTag = $"{PnPCoreUtilities.PnPCoreVersionTag}:ProcessFeatureInternal"; if (clientTag.Length > 32) { clientTag = clientTag.Substring(0, 32); } features.Context.ClientTag = clientTag; // Don't update this to ExecuteQueryRetry features.Context.ExecuteQuery(); Log.Info(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_ProcessFeatureInternal_FeatureActive, featureID); } catch (Exception ex) { Log.Info(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_ProcessFeatureInternal_FeatureException, ex.ToString()); // Don't wait for a "feature not found" exception, which is the typical exception we'll see if (ex.HResult != -2146233088) { int retryAttempts = 10; int retryCount = 0; // wait and keep checking if the feature is active while (retryAttempts > retryCount) { Thread.Sleep(TimeSpan.FromSeconds(pollingIntervalSeconds)); if (IsFeatureActiveInternal(features, featureID, true)) { retryCount = retryAttempts; Log.Info(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_ProcessFeatureInternal_FeatureActivationState, true, featureID); } else { retryCount++; Log.Info(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_ProcessFeatureInternal_FeatureActivationState, false, featureID); } } } } } else { try { features.Remove(featureID, false); features.Context.ExecuteQueryRetry(); } catch (Exception ex) { Log.Error(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_FeatureActivationProblem, featureID, ex.Message); } } }
private void ProcessFeature( object modelHost, ClientRuntimeContext context, FeatureCollection features, FeatureDefinition featureModel, Microsoft.SharePoint.Client.FeatureDefinitionScope scope) { var featureId = featureModel.Id; var currentFeature = features.GetById(featureId); features.Context.ExecuteQueryWithTrace(); var featureActivated = IsFeatureActivated(currentFeature); TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Is feature activated: [{0}]", featureActivated); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioning, Object = currentFeature, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); if (!featureActivated) { Feature tmpFeature; if (featureModel.Enable) { TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Enabling feature"); tmpFeature = SafelyActivateWebFeature(context, features, featureModel, scope); } else { TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Fetching feature by ID"); tmpFeature = features.GetById(featureId); features.Context.ExecuteQueryWithTrace(); } InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioned, Object = tmpFeature, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); } else { if (featureModel.Enable && featureModel.ForceActivate) { TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Feature enabled, but ForceActivate = true. Force activating."); var f = SafelyActivateWebFeature(context, features, featureModel, scope); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioned, Object = f, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); } else if (!featureModel.Enable) { TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Removing feature."); features.Remove(featureModel.Id, featureModel.ForceActivate); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioned, Object = null, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); context.ExecuteQueryWithTrace(); } else { TraceService.Verbose((int)LogEventId.ModelProvisionCoreCall, "Fetching feature by ID"); var tmpFeature = features.GetById(featureId); features.Context.ExecuteQueryWithTrace(); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioned, Object = tmpFeature, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); } } }
/// <summary> /// Activates or deactivates a site collection or web scoped feature /// </summary> /// <param name="features">Feature Collection which contains the feature</param> /// <param name="featureID">ID of the feature to activate/deactivate</param> /// <param name="activate">True to activate, false to deactivate the feature</param> /// <param name="scope">Scope of the feature definition</param> /// <param name="pollingIntervalSeconds">The time in seconds between polls for "IsActive"</param> private static void ProcessFeatureInternal(FeatureCollection features, Guid featureID, bool activate, FeatureDefinitionScope scope, int pollingIntervalSeconds = 30) { if (activate) { // Feature enabling can take a long time, especially in case of the publishing feature...so let's make it more reliable bool cancel = false; features.Add(featureID, true, scope); if (pollingIntervalSeconds < 5) { pollingIntervalSeconds = 5; } // Kick off a thread that checks for the feature activation to be complete Task.Run(() => { while (!cancel) { Thread.Sleep(TimeSpan.FromSeconds(pollingIntervalSeconds)); if (!cancel) { cancel = IsFeatureActiveInternal(features, featureID); Log.Info(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_ProcessFeatureInternal_FeatureActivationState, cancel, featureID); } } }); // Kick off a thread that enables the feature Task.Run(() => { try { features.Context.ExecuteQueryRetry(); Log.Info(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_ProcessFeatureInternal_FeatureActive, featureID); } catch(Exception ex) { Log.Info(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_ProcessFeatureInternal_FeatureException, ex.ToString()); } finally { cancel = true; } }).Wait(); } else { try { features.Remove(featureID, false); features.Context.ExecuteQueryRetry(); } catch (Exception ex) { Log.Error(Constants.LOGGING_SOURCE, CoreResources.FeatureExtensions_FeatureActivationProblem, featureID, ex.Message); } } }
private static void DeActivateFeatureInCollection(ClientContext clientContext, ShFeature featureInfo, FeatureCollection featureCollection) { clientContext.Load(featureCollection); clientContext.ExecuteQuery(); if (DoesFeatureExistInCollection(featureCollection, featureInfo.FeatureId)) { Log.Info("Deactivating feature " + featureInfo.FeatureName); featureCollection.Remove(featureInfo.FeatureId, true); clientContext.ExecuteQuery(); } }
private void ProcessFeature( object modelHost, ClientRuntimeContext context, FeatureCollection features, FeatureDefinition featureModel, Microsoft.SharePoint.Client.FeatureDefinitionScope scope) { var currentFeature = GetFeature(features, featureModel); var featureActivated = IsFeatureActivated(features, featureModel); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioning, Object = currentFeature, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); if (!featureActivated) { Feature tmpFeature; if (featureModel.Enable) { tmpFeature = features.Add(featureModel.Id, featureModel.ForceActivate, scope); context.ExecuteQuery(); } else { tmpFeature = GetFeature(features, featureModel); } InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioned, Object = tmpFeature, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); } else { if (featureModel.Enable && featureModel.ForceActivate) { var f = features.Add(featureModel.Id, featureModel.ForceActivate, scope); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioned, Object = f, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); context.ExecuteQuery(); } else if (!featureModel.Enable) { features.Remove(featureModel.Id, featureModel.ForceActivate); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioned, Object = null, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); context.ExecuteQuery(); } else { var tmpFeature = GetFeature(features, featureModel); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioned, Object = tmpFeature, ObjectType = typeof(Feature), ObjectDefinition = featureModel, ModelHost = modelHost }); } } }