private void iInstallFeature(Guid gFeatureId, SPFeatureDefinition def, SPFeatureDefinitionScope scope, int ParentMessageId) { switch (def.Scope) { case SPFeatureScope.Site: if (!bVerifyOnly) { oWeb.Site.Features.Add(gFeatureId, true, scope); } addMessage(ErrorLevels.NoError, def.DisplayName, string.Empty, ParentMessageId); break; case SPFeatureScope.Web: if (!bVerifyOnly) { oWeb.Features.Add(gFeatureId, true, scope); } addMessage(ErrorLevels.NoError, def.DisplayName, string.Empty, ParentMessageId); break; default: addMessage(ErrorLevels.Warning, def.DisplayName, "Feature Not scoped for Site or Web", ParentMessageId); break; } }
private Control GetPackageControlForFeature(SPFeatureDefinition feature) { Control c = new Control(); string name = feature.Properties["SPSIN_ConfigPackage_Title"].Value; string description = "No Description Available"; if (feature.Properties["SPSIN_ConfigPackage_Description"] != null) { description = feature.Properties["SPSIN_ConfigPackage_Description"].Value; } string htmlString = string.Format(@" <h2>{0}</h2> <p>{1}</p> ", name, description); Button addButton = new Button(); addButton.ID = "add_" + feature.Id; addButton.Click += new EventHandler(addButton_Click); addButton.Text = "Add " + name; Panel packagePanel = new Panel(); packagePanel.Controls.Add(new LiteralControl(htmlString)); packagePanel.Controls.Add(addButton); packagePanel.CssClass = "SPSIN-packagePanel"; c.Controls.Add(packagePanel); return(c); }
public static FeatureDefinition ToFeatureDefinition(this SPFeatureDefinition spFeatureDefinition, string definitionInstallationScope) { var cultureInfo = new System.Globalization.CultureInfo(1033); if (spFeatureDefinition == null) { return(null); } var fd = FeatureDefinitionFactory.GetFeatureDefinition( spFeatureDefinition.Id, spFeatureDefinition.CompatibilityLevel, spFeatureDefinition.GetDescription(cultureInfo), spFeatureDefinition.DisplayName, spFeatureDefinition.Hidden, spFeatureDefinition.Name, spFeatureDefinition.Properties == null ? null : spFeatureDefinition.Properties.ToProperties(), spFeatureDefinition.Scope.ToScope(), spFeatureDefinition.GetTitle(cultureInfo), spFeatureDefinition.SolutionId, spFeatureDefinition.UIVersion, spFeatureDefinition.Version, definitionInstallationScope); return(fd); }
void InstallMenuItem_Click(object sender, EventArgs e) { Cursor.Current = Cursors.WaitCursor; Explorer.Update(); // Feature is not installed. string path = this.Tag as string; DirectoryInfo info = new DirectoryInfo(path); string featureName = info.Name + @"\feature.xml"; SPFarm spFarm = Explorer.CurrentFarm; SPFeatureDefinition definition = spFarm.FeatureDefinitions.Add(featureName, Guid.Empty, true); SPFeatureDefinition dd = new SPFeatureDefinition(); this.Text = definition.DisplayName; this.Name = definition.Id.ToString(); this.Tag = definition; FeatureCollectionDefinitionNode nodeCollection = (FeatureCollectionDefinitionNode)this.Parent; this.ImageIndex = nodeCollection.InstalledIndex; this.SelectedImageIndex = nodeCollection.InstalledIndex; IsInstalled = true; Explorer.EndUpdate(); Explorer.Refresh(); //Program.Window.propertyGrid.SelectedObject = this.Tag; Cursor.Current = Cursors.Default; }
public static string GetFeatureScript(string scriptName) { SPFeatureDefinition centralAdminFeature = SPFarm.Local.FeatureDefinitions[PowerWebPartConstants.CentralAdminFeatureId]; string scriptPath = Path.Combine(centralAdminFeature.RootDirectory, "Scripts\\" + scriptName); return(File.ReadAllText(scriptPath)); }
/// <summary> /// Activates a feature on a given SharePoint Web site, if that feature is not yet active. /// </summary> /// /// <param name="webSiteUrl">The URL of the Web site.</param> /// /// <param name="featureName">The name of the feature.</param> /// static void ActivateFeatureOnWebSite(string webSiteUrl, string featureName) { Console.WriteLine("Activating feature \"{0}\" on Web site \"{1}\"", featureName, webSiteUrl); using (SPSite spSite = new SPSite(webSiteUrl)) { SPFeatureDefinition featureDefinition = spSite.WebApplication.Farm.FeatureDefinitions[featureName]; if (featureDefinition == null) { throw new Exception(String.Format("Feature \"{0}\" not found", featureName)); } using (SPWeb spWeb = spSite.OpenWeb()) { SPFeature feature = spWeb.Features[featureDefinition.Id]; if (feature != null) { Console.WriteLine("...exists already"); } else { spWeb.Features.Add(featureDefinition.Id); Console.WriteLine("...created"); } } } }
public static List <AttributeValuePair> GetSPFeatureDefinitionAttributes(SPFeatureDefinition featureDef) { List <AttributeValuePair> featureDefAttributes = new List <AttributeValuePair>(); try { featureDefAttributes.Add(new AttributeValuePair("DisplayName", featureDef.DisplayName)); featureDefAttributes.Add(new AttributeValuePair("Id", featureDef.Id.ToString())); featureDefAttributes.Add(new AttributeValuePair("Scope", featureDef.Scope.ToString())); featureDefAttributes.Add(new AttributeValuePair("Hidden", featureDef.Hidden.ToString())); featureDefAttributes.Add(new AttributeValuePair("Name", featureDef.Name.ToString())); // suppress full feature path featureDefAttributes.Add(new AttributeValuePair("RootDirectory", featureDef.RootDirectory.Replace(SPUtility.GetGenericSetupPath(@"Template"), ""))); featureDefAttributes.Add(new AttributeValuePair("Version", featureDef.Version.ToString())); featureDefAttributes.Add(new AttributeValuePair("Status", featureDef.Status.ToString())); featureDefAttributes.Add(new AttributeValuePair("SolutionId", featureDef.SolutionId.ToString())); if (featureDef.ReceiverAssembly != null) { featureDefAttributes.Add(new AttributeValuePair("ReceiverAssembly", featureDef.ReceiverAssembly.ToString())); featureDefAttributes.Add(new AttributeValuePair("ReceiverClass", featureDef.ReceiverClass.ToString())); } } catch (Exception e) { featureDefAttributes.Add(new AttributeValuePair("Exception", e.ToString())); } return(featureDefAttributes); }
/// <summary> /// Activates or deactivates the feature at the specified scope. /// </summary> /// <param name="scope">The scope.</param> /// <param name="featureId">The feature id.</param> /// <param name="activate">if set to <c>true</c> [activate].</param> /// <param name="url">The URL.</param> /// <param name="force">if set to <c>true</c> [force].</param> /// <param name="ignoreNonActive">if set to <c>true</c> [ignore non active].</param> internal void ActivateDeactivateFeatureAtScope(ActivationScope scope, Guid featureId, bool activate, string url, bool force, bool ignoreNonActive) { Logger.Verbose = true; m_FeatureId = featureId; if (m_FeatureId.Equals(Guid.Empty)) { throw new SPException("Unable to locate Feature."); } SPFeatureDefinition feature = SPFarm.Local.FeatureDefinitions[m_FeatureId]; if (feature == null) { throw new SPException("Unable to locate Feature."); } if (scope == ActivationScope.Feature) { scope = (ActivationScope)Enum.Parse(typeof(ActivationScope), feature.Scope.ToString().ToLowerInvariant(), true); } ActivateDeactivateFeatureAtScope(feature, scope, activate, url, force, ignoreNonActive); }
protected override IEnumerable <SPFeature> RetrieveDataObjects() { List <SPFeature> features = new List <SPFeature>(); switch (ParameterSetName) { case "SPFeature": foreach (SPFeatureDefinitionPipeBind fdpb in Identity) { SPFeatureDefinition feature = fdpb.Read(); GetFeatureActivations(features, feature, NeedsUpgrade); } break; case "SPSolution": foreach (SPSolutionPipeBind spb in Solution) { SPSolution solution = spb.Read(); List <SPFeatureDefinition> featureDefinitions = SPFarm.Local.FeatureDefinitions.Where(fd => fd.SolutionId == solution.Id).ToList(); foreach (SPFeatureDefinition feature in featureDefinitions) { GetFeatureActivations(features, feature, NeedsUpgrade); } } break; } return(features); }
private void btnRemove_Click(object sender, RoutedEventArgs e) { if (lstSite.SelectedIndex != -1) { SPFeatureDefinition definition = lstSite.SelectedItem as SPFeatureDefinition; site.Features.Remove(definition.Id); ReadSource(); } }
public SPFeatureDefinitionInstance Construct(SPFeatureDefinition featureDefinition) { if (featureDefinition == null) { throw new ArgumentNullException("featureDefinition"); } return(new SPFeatureDefinitionInstance(this.InstancePrototype, featureDefinition)); }
public WebSiteZoneModifier(SPWebApplication application, Guid featureID, bool delete) : base("Zone Modifier for " + application.Name, application, null, SPJobLockType.None) { SPFeatureDefinition def = application.Features[featureID].Definition; string szone = def.Properties[zoneKey].Value; this.Zone = (SPUrlZone)Enum.Parse(typeof(SPUrlZone), szone, true); this.Url = def.Properties[urlKey].Value; this._delete = delete; }
private void AddFeaturesInSolutionLVI(SPFeatureDefinition f) { ListViewItem lvi = new ListViewItem(); lvi.SubItems.Add(f.DisplayName); lvi.SubItems.Add(f.Scope.ToString()); lvi.SubItems.Add(f.Hidden.ToString()); lvi.SubItems.Add(f.Version.ToString()); lvi.Tag = f; lvSolutions.Items.Add(lvi); }
/// <summary> /// Activates or deactivates the feature. /// </summary> /// <param name="features">The features.</param> /// <param name="activate">if set to <c>true</c> [activate].</param> /// <param name="featureId">The feature id.</param> /// <param name="urlScope">The URL scope.</param> /// <param name="force">if set to <c>true</c> [force].</param> /// <param name="ignoreNonActive">if set to <c>true</c> [ignore non active].</param> /// <returns></returns> private SPFeature ActivateDeactivateFeature(SPFeatureCollection features, bool activate, Guid featureId, string urlScope, bool force, bool ignoreNonActive) { if (features[featureId] == null && ignoreNonActive) { return(null); } if (!activate) { if (features[featureId] != null || force) { Logger.Write("Progress: Deactivating Feature {0} from {1}.", featureId.ToString(), urlScope); try { features.Remove(featureId, force); } catch (Exception ex) { Logger.WriteWarning("{0}", ex.Message); } } else { Logger.WriteWarning("" + SPResource.GetString("FeatureNotActivatedAtScope", new object[] { featureId }) + " Use the -force parameter to force a deactivation."); } return(null); } if (features[featureId] == null) { Logger.Write("Progress: Activating Feature {0} on {1}.", featureId.ToString(), urlScope); } else { if (!force) { SPFeatureDefinition fd = features[featureId].Definition; Logger.WriteWarning("" + SPResource.GetString("FeatureAlreadyActivated", new object[] { fd.DisplayName, fd.Id, urlScope }) + " Use the -force parameter to force a reactivation."); return(features[featureId]); } Logger.Write("Progress: Re-Activating Feature {0} on {1}.", featureId.ToString(), urlScope); } try { return(features.Add(featureId, force)); } catch (Exception ex) { Logger.WriteException(new System.Management.Automation.ErrorRecord(ex, null, System.Management.Automation.ErrorCategory.NotSpecified, features)); return(null); } }
public static int GetFeatureCompatibilityLevel(SPFeatureDefinition definition) { #if (SP2013) { return(definition.CompatibilityLevel); } #else { return(Feature.COMPATINAPPLICABLE); // inapplicable } #endif }
public static string GetElementDefinition(ISharePointCommandContext context, FeatureElementInfo elementInfo) { SPFeatureDefinition definition = SPFarm.Local.FeatureDefinitions[elementInfo.FeatureID]; SPElementDefinition element = definition.GetElementDefinitions(CultureInfo.CurrentCulture) .OfType <SPElementDefinition>() .Where(searchElement => searchElement.ElementType == elementInfo.ElementType) .Where(searchElement => GetNameFromNode(searchElement.XmlDefinition) == elementInfo.Name) .FirstOrDefault(); return(element.XmlDefinition.OuterXml); }
private void GetFeatureScopeFromDefinition(SPFeatureDefinition fdef, ref Feature feature) { try { feature.Scope = fdef.Scope; } catch (Exception exc) { feature.AppendExceptionMsg(exc); feature.IsFaulty = true; } }
/// <summary> /// /// </summary> /// <param name="service"></param> /// <param name="featureID"></param> /// <param name="delete"></param> public WebSiteDocItemModifier(SPService service, Guid featureID, bool delete) : base("DocIcon Modifier for " + featureID.ToString(), service, null, SPJobLockType.None) { this._featureID = featureID; SPFeatureDefinition def = Farm.FeatureDefinitions[featureID]; this.Key = def.Properties[keyKey].Value; this.Value = def.Properties[valueKey].Value; this.EditText = def.Properties[textKey].Value; this.OpenControl = def.Properties[controlKey].Value; this.docIconType = def.Properties[typeKey].Value; this._delete = delete; }
private void GetFeatureCompatibilityFromDefinition(SPFeatureDefinition fdef, ref Feature feature) { try { feature.CompatibilityLevel = FeatureManager.GetFeatureCompatibilityLevel(fdef); } catch (Exception exc) { feature.AppendExceptionMsg(exc); feature.IsFaulty = true; } }
private string GetProvisioinerFilePath(SPFeatureDefinition featureDefinition) { string sharepointFeaturesDir = this.GetSharePointFeaturesDirectory(); string filePath = String.Empty; if (featureDefinition != null && !String.IsNullOrEmpty(sharepointFeaturesDir)) { string featureName = featureDefinition.DisplayName; string featureDir = Path.Combine(sharepointFeaturesDir, featureName); filePath = Path.Combine(featureDir, "SiteProvisioning.xml"); } return filePath; }
void addButton_Click(object sender, EventArgs e) { SPContext context = SPContext.Current; if (context != null) { SPWeb web = context.Web; Control b = (Control)sender; string[] parts = b.ID.Split('_'); if (parts.Length == 2 && parts[0] == "add") { string featureID = parts[1]; SPFeatureDefinition def = SPFarm.Local.FeatureDefinitions[new Guid(featureID)]; if (def == null) { // Maybe sandbox... if (SPFarm.Local.BuildVersion > new Version("14.0.0.0")) { //Load handler for sandbox solutions try { ConfigurationPackageHandler handler = Utilities.GetConfigurationPackageHandlerForSandbox(); handler.AddConfigurationPackage(featureID, web); SPSIN_Message.Text = "Configuration Added"; } catch (Exception ex) { throw new SPException("Sorry, we cannot add that package. " + ex.Message); } } } else if (def.Scope == SPFeatureScope.Web) { if (web.Features[new Guid(featureID)] == null) { web.Features.Add(new Guid(featureID)); web.Features.Remove(new Guid(featureID)); SPSIN_Message.Text = "Configuration Added"; } } else { throw new SPException(string.Format("Sorry, the package with the feature ID {0} seems to be an invalid SP SIN configuration package. We even tried treating it as a sandbox solution. An SP SIN Configuration package needs to be web scoped (tell your developer) and you need to have permissions to activate the feature.", featureID)); } } } }
private static string GetProvisioinerFilePath(SPFeatureDefinition featureDefinition) { string sharepointFeaturesDir = GetSharePointFeaturesDirectory(); string filePath = String.Empty; if (featureDefinition != null && !String.IsNullOrEmpty(sharepointFeaturesDir)) { string featureName = featureDefinition.DisplayName; string featureDir = Path.Combine(sharepointFeaturesDir, featureName); filePath = Path.Combine(featureDir, "SiteProvisioning.xml"); } return(filePath); }
public static string GetFeatureName(Guid?featureId) { if (featureId == null) { return("NULL feature ID"); } SPFeatureDefinition fdef = SPFarm.Local.FeatureDefinitions[featureId.Value]; if (fdef == null) { return(featureId.ToString()); } return(fdef.DisplayName + " (" + featureId.ToString() + ")"); }
private void btnAdd_Click(object sender, RoutedEventArgs e) { if (lstFarm.SelectedIndex != -1) { SPFeatureDefinition definition = lstFarm.SelectedItem as SPFeatureDefinition; if (definition.Scope == SPFeatureScope.Site) { site.Features.Add(definition.Id); } if (definition.Scope == SPFeatureScope.Web) { web.Features.Add(definition.Id); } ReadSource(); } }
/// <summary> /// Gets the feature activations. /// </summary> /// <param name="features">The features.</param> /// <param name="fd">The fd.</param> /// <param name="needsUpgrade">if set to <c>true</c> [needs upgrade].</param> private void GetFeatureActivations(List <SPFeature> features, SPFeatureDefinition fd, bool needsUpgrade) { switch (fd.Scope) { case SPFeatureScope.Farm: features.AddRange(SPWebService.AdministrationService.QueryFeatures(fd.Id, needsUpgrade)); break; case SPFeatureScope.WebApplication: features.AddRange(SPWebService.QueryFeaturesInAllWebServices(fd.Id, needsUpgrade)); break; case SPFeatureScope.Site: foreach (SPService svc in SPFarm.Local.Services) { if (!(svc is SPWebService)) { continue; } foreach (SPWebApplication webApp in ((SPWebService)svc).WebApplications) { features.AddRange(webApp.QueryFeatures(fd.Id, needsUpgrade)); } } break; case SPFeatureScope.Web: foreach (SPService svc in SPFarm.Local.Services) { if (!(svc is SPWebService)) { continue; } foreach (SPWebApplication webApp in ((SPWebService)svc).WebApplications) { foreach (SPSite site in webApp.Sites) { features.AddRange(site.QueryFeatures(fd.Id, needsUpgrade)); site.Dispose(); } } } break; } }
public static FeatureDependencyInfo[] GetFeatureDependencies(ISharePointCommandContext context, FeatureInfo featureID) { List <FeatureDependencyInfo> dependencies = new List <FeatureDependencyInfo>(); SPFeatureDefinition definition = SPFarm.Local.FeatureDefinitions[featureID.FeatureID]; foreach (SPFeatureDependency dependency in definition.ActivationDependencies) { SPFeatureDefinition dependencyDefinition = SPFarm.Local.FeatureDefinitions[dependency.FeatureId]; dependencies.Add(new FeatureDependencyInfo() { FeatureID = dependency.FeatureId, MinimumVersion = dependency.MinimumVersion.ToString(), Title = dependencyDefinition.GetTitle(CultureInfo.CurrentCulture) }); } return(dependencies.ToArray()); }
public override void FeatureActivated(SPFeatureReceiverProperties properties) { featureDefinition = properties.Feature.Definition; SPWebApplication webApp = (SPWebApplication)properties.Feature.Parent; webApp.WebConfigModifications.Add(GetModification()); webApp.Update(); webApp.WebService.ApplyWebConfigModifications(); ServiceLocatorConfig typeMappings = new ServiceLocatorConfig(); typeMappings.RegisterTypeMapping <IIncidentManagementRepository, IncidentManagementRepository>(); typeMappings.RegisterTypeMapping <IPricingRepository, PricingRepository>(); typeMappings.RegisterTypeMapping <IProductCatalogRepository, CachedBdcProductCatalogRepository>(); }
public FeatureNode(object spParent, SPFeatureDefinition definition, int imageIndex, bool installed) { this.Tag = definition; this.SPParent = spParent; this.ImageIndex = imageIndex; this.SelectedImageIndex = imageIndex; this.IsInstalled = installed; try { if (definition.Hidden) { _Text = definition.GetTitle(SPMConfig.Instance.CultureInfo) + " (Hidden)"; this.ForeColor = Color.DarkGray; } else { _Text = definition.GetTitle(SPMConfig.Instance.CultureInfo); } _ToolTip = definition.GetDescription(SPMConfig.Instance.CultureInfo); _Name = definition.Id.ToString(); this.Setup(); this.Nodes.Add(new ExplorerNodeBase("Dummy")); } catch(Exception ex) { this.ForeColor = Color.DarkRed; if (definition != null) { _Text = definition.RootDirectory.ToLower() + " (error)"; _ToolTip = ex.Message; _Name = definition.Id.ToString(); } else { _Text = "(Error: Can not find feature definition)"; _ToolTip = ex.Message; _Name = Guid.Empty.ToString(); } } }
public FeatureNode(object spParent, SPFeatureDefinition definition, int imageIndex, bool installed) { this.Tag = definition; this.SPParent = spParent; this.ImageIndex = imageIndex; this.SelectedImageIndex = imageIndex; this.IsInstalled = installed; try { if (definition.Hidden) { _Text = definition.GetTitle(SPMConfig.Instance.CultureInfo) + " (Hidden)"; this.ForeColor = Color.DarkGray; } else { _Text = definition.GetTitle(SPMConfig.Instance.CultureInfo); } _ToolTip = definition.GetDescription(SPMConfig.Instance.CultureInfo); _Name = definition.Id.ToString(); this.Setup(); this.Nodes.Add(new ExplorerNodeBase("Dummy")); } catch (Exception ex) { this.ForeColor = Color.DarkRed; if (definition != null) { _Text = definition.RootDirectory.ToLower() + " (error)"; _ToolTip = ex.Message; _Name = definition.Id.ToString(); } else { _Text = "(Error: Can not find feature definition)"; _ToolTip = ex.Message; _Name = Guid.Empty.ToString(); } } }
/// <summary> /// Get Feature Type /// </summary> public FeatureType GetFeatureType(SPFeatureDefinition featureDefinition) { if (sharePoint2007Features.Contains(featureDefinition.DisplayName)) { return(FeatureType.SharePoint); } if (nintexFeatures.Contains(featureDefinition.DisplayName)) { return(FeatureType.Nintex); } if (nextDocsFeatures.Contains(featureDefinition.DisplayName)) { return(FeatureType.NextDocs); } else { return(FeatureType.Custom); } }
public static int GetFeatureCompatibilityLevel(SPFeatureDefinition definition) { #if (SP2013) { return(definition.CompatibilityLevel); } #endif #if (SP2010) { return(COMPATINAPPLICABLE); // inapplicable } #endif #if (SP2007) { return(Feature.COMPATINAPPLICABLE); // inapplicable } #endif throw new Exception("Unspecified SharePoint Version"); }
public static int GetFeatureCompatibilityLevel(SPFeatureDefinition definition) { #if (SP2013) { return definition.CompatibilityLevel; } #endif #if (SP2010) { return COMPATINAPPLICABLE; // inapplicable } #endif #if (SP2007) { return Feature.COMPATINAPPLICABLE; // inapplicable } #endif throw new Exception("Unspecified SharePoint Version"); }
private void FeatureSelected(object sender, EventArgs e) { if (lvSolutions.SelectedItems.Count > 0) { CurrentFeature = (SPFeatureDefinition)lvSolutions.SelectedItems[0].Tag; gbSites.Text = "Sites using " + CurrentFeature.DisplayName; lvWebs.Items.Clear(); List <SPWeb> sites = SPBroker.GetSitesUsingFeature(CurrentFeature.Id); foreach (SPWeb web in sites) { AddFeaturesInWebLvi(web, UsageType.Direct); } foreach (SPWeb web in SPBroker.GetSitesUsingFeatureInDependency(CurrentFeature.Id)) { AddFeaturesInWebLvi(web, UsageType.Dependency); } } }
public FeatureDefinitionNode(object spParent, SPFeatureDefinition definition, int installedIndex, int unInstalledIndex) { this.Tag = definition; this.SPParent = spParent; this.InstalledIndex = installedIndex; this.UnInstalledIndex = unInstalledIndex; _Text = definition.GetTitle(SPMConfig.Instance.CultureInfo); _ToolTip = definition.GetDescription(SPMConfig.Instance.CultureInfo); _Name = definition.Id.ToString(); if (definition.Status != SPObjectStatus.Online) { _Text += " (" + definition.Status.ToString() + ")"; } this.ImageIndex = InstalledIndex; this.SelectedImageIndex = InstalledIndex; this.Setup(); this.Nodes.Add(new ExplorerNodeBase("Dummy")); }
internal void ActivateDeactivateFeatureAtScope(SPFeatureDefinition feature, ActivationScope scope, bool activate, string url, bool force, bool ignoreNonActive) { m_IgnoreNonActive = ignoreNonActive; m_Activate = activate; m_Force = force; m_Url = url; m_FeatureId = feature.Id; if (feature.Scope == SPFeatureScope.Farm) { if (scope != ActivationScope.Farm) throw new SPSyntaxException("The Feature specified is scoped to the Farm. The -scope parameter must be \"Farm\"."); ActivateDeactivateFeatureAtFarm(activate, m_FeatureId, m_Force, m_IgnoreNonActive); } else if (feature.Scope == SPFeatureScope.WebApplication) { if (scope != ActivationScope.Farm && scope != ActivationScope.WebApplication) throw new SPSyntaxException("The Feature specified is scoped to the Web Application. The -scope parameter must be either \"Farm\" or \"WebApplication\"."); if (scope == ActivationScope.Farm) { SPEnumerator enumerator = new SPEnumerator(SPFarm.Local); enumerator.SPWebApplicationEnumerated += enumerator_SPWebApplicationEnumerated; enumerator.Enumerate(); } else { if (string.IsNullOrEmpty(m_Url)) throw new SPSyntaxException("The -url parameter is required if the scope is \"WebApplication\"."); SPWebApplication webApp = SPWebApplication.Lookup(new Uri(m_Url)); ActivateDeactivateFeatureAtWebApplication(webApp, m_FeatureId, activate, m_Force, m_IgnoreNonActive); } } else if (feature.Scope == SPFeatureScope.Site) { if (scope == ActivationScope.Web) throw new SPSyntaxException("The Feature specified is scoped to Site. The -scope parameter cannot be \"Web\"."); SPSite site = null; SPEnumerator enumerator = null; try { if (scope == ActivationScope.Farm) enumerator = new SPEnumerator(SPFarm.Local); else if (scope == ActivationScope.WebApplication) { SPWebApplication webApp = SPWebApplication.Lookup(new Uri(m_Url)); enumerator = new SPEnumerator(webApp); } else if (scope == ActivationScope.Site) { site = new SPSite(m_Url); ActivateDeactivateFeatureAtSite(site, activate, m_FeatureId, m_Force, m_IgnoreNonActive); } if (enumerator != null) { enumerator.SPSiteEnumerated += enumerator_SPSiteEnumerated; enumerator.Enumerate(); } } finally { if (site != null) site.Dispose(); } } else if (feature.Scope == SPFeatureScope.Web) { SPSite site = null; SPWeb web = null; SPEnumerator enumerator = null; try { if (scope == ActivationScope.Farm) enumerator = new SPEnumerator(SPFarm.Local); else if (scope == ActivationScope.WebApplication) { SPWebApplication webApp = SPWebApplication.Lookup(new Uri(m_Url)); enumerator = new SPEnumerator(webApp); } else if (scope == ActivationScope.Site) { site = new SPSite(m_Url); enumerator = new SPEnumerator(site); } else if (scope == ActivationScope.Web) { site = new SPSite(m_Url); web = site.AllWebs[Utilities.GetServerRelUrlFromFullUrl(m_Url)]; enumerator = new SPEnumerator(web); } if (enumerator != null) { enumerator.SPWebEnumerated += enumerator_SPWebEnumerated; enumerator.Enumerate(); } } finally { if (web != null) web.Dispose(); if (site != null) site.Dispose(); } } }
private void GetFeatureNameFromDefinition(SPFeatureDefinition fdef, ref Feature feature) { try { feature.Name = fdef.GetTitle(System.Threading.Thread.CurrentThread.CurrentCulture); return; } catch (Exception exc) { feature.AppendExceptionMsg(exc); feature.IsFaulty = true; } try { feature.Name = fdef.DisplayName; return; } catch (Exception exc) { feature.AppendExceptionMsg(exc); feature.IsFaulty = true; } }
/// <summary> /// Returns the full path of the Feature folder. /// </summary> /// <param name="featureDefinition">Feature definition object.</param> /// <returns>Full path of the feature folder.</returns> private static string GetFeatureFolder(SPFeatureDefinition featureDefinition) { if (featureDefinition == null) { throw new ArgumentNullException("featureDefinition"); } string featureFolder = Path.Combine(SPUtility.GetGenericSetupPath(@"Template\Features"), featureDefinition.DisplayName); if (Directory.Exists(featureFolder) == false) { throw new InvalidDataException(string.Format(CultureInfo.CurrentCulture, "Feature folder '{0}' does not exists.", featureFolder)); } return featureFolder; }
private static XmlDocument GetXmlDocument(SPFeatureDefinition definition, String path, CultureInfo info) { return (XmlDocument)(Type.GetType(SPXmlDocCacheAssembly).InvokeMember("GetLocalizedXmlDocument", BindingFlags.InvokeMethod | BindingFlags.NonPublic | BindingFlags.Static, null, null, new object[] { definition, GetRelativePath(path, definition.RootDirectory), info })); }
private static CachedElementDefinition? GetElementInfoFromElementDefinition(SPFeatureDefinition featureDefinition, string elementType, string idAttributeName, object id) { var elementCollection = featureDefinition.GetElementDefinitions(CultureInfo.InvariantCulture); CachedElementDefinition? ret = null; foreach (SPElementDefinition e in elementCollection) { if (e.ElementType == "ContentType" || e.ElementType == "Field" || e.ElementType == "ListInstance" || e.ElementType == "ListTemplate") { string elementId; if (e.ElementType == "ContentType" || e.ElementType == "Field") { elementId = SPGENCommon.GetElementDefinitionAttribute(e.XmlDefinition.Attributes, "ID"); } else if (e.ElementType == "ListInstance") { elementId = SPGENCommon.GetElementDefinitionAttribute(e.XmlDefinition.Attributes, "Url"); } else { elementId = SPGENCommon.GetElementDefinitionAttribute(e.XmlDefinition.Attributes, "Type"); } string key = CreateKey(e.ElementType, elementId); if (_cache.Exists(key)) continue; var elementInfo = new CachedElementDefinition(); elementInfo.ElementXml = e.XmlDefinition.Clone(); elementInfo.FeatureId = featureDefinition.Id; bool equals = false; if (e.ElementType == elementType) { if (id is Guid) { if ((Guid)id == new Guid(elementId)) equals = true; } else if (id is SPContentTypeId) { if ((SPContentTypeId)id == new SPContentTypeId(elementId)) equals = true; } else { if ((string)id == elementId) equals = true; } } if (!equals) { if (e.ElementType == "ListTemplate") { key += "_" + e.FeatureDefinition.Id.ToString("N").ToUpper(); } _cache.Insert(key, elementInfo, true); } else { ret = elementInfo; } } } return ret; }
private static void PreloadDefinitionIntoCache(SPFeatureDefinition featureDefinition, string idAttributeName) { var coll = featureDefinition.GetElementDefinitions(CultureInfo.InvariantCulture); foreach (SPElementDefinition element in coll) { string elementId = (element.XmlDefinition as XmlElement).GetAttribute(idAttributeName); string key = CreateKey(element.ElementType, elementId); if (_cache.Exists(key)) continue; var elementInfo = new CachedElementDefinition(); elementInfo.ElementXml = element.XmlDefinition.Clone(); elementInfo.FeatureId = featureDefinition.Id; if (element.ElementType == "ListTemplate") { key += "_" + element.FeatureDefinition.Id.ToString("N").ToUpper(); } _cache.Insert(key, elementInfo, false); } }