public Status CheckFeature(SPFeature feature) { Status status = new Status(); try { status.FeatureId = feature.DefinitionId; } catch { status.Faulty = true; } try { status.CompatibilityLevel = FeatureManager.GetFeatureCompatibilityLevel(feature.Definition); } catch { status.Faulty = true; } try { // a feature activated somewhere with no manifest file available causes // an error when asking for the DisplayName // If this happens, we found a faulty feature status.DisplayName = feature.Definition.DisplayName; } catch { status.Faulty = true; } return status; }
/// <summary> /// Creates a new child lifetime scope that is as nested as possible, /// depending on the scope of the specified feature. /// In a SPSite or SPWeb-scoped feature context, will return a web-specific /// lifetime scope (allowing you to inject InstancePerSite and InstancePerWeb /// objects). /// In a SPFarm or SPWebApplication feature context, will return a child /// container of the root application container (preventing you from injecting /// InstancePerSite, InstancePerWeb or InstancePerRequest objects). /// Please dispose this lifetime scope when done (E.G. call this method from /// a using block). /// Prefer usage of this method versus resolving indididual dependencies from the /// ISharePointServiceLocator.Current property. /// </summary> /// <param name="feature">The current feature that is requesting a child lifetime scope</param> /// <returns>A new child lifetime scope which should be disposed by the caller.</returns> public ILifetimeScope BeginFeatureLifetimeScope(SPFeature feature) { ILifetimeScope newChildScopeAsNestedAsPossible = null; SPSite currentFeatureSite = feature.Parent as SPSite; SPWeb currentFeatureWeb = null; if (currentFeatureSite == null) { // this is a Web-scoped feature, not a Site-scoped one currentFeatureWeb = feature.Parent as SPWeb; } else { // this is a Site-scope feature, use the RootWeb as current currentFeatureWeb = currentFeatureSite.RootWeb; } if (currentFeatureWeb == null) { // Can't use an AddOnProvidedServiceLocator this way outside a SPSite context (e.g. no SPFarm or SPWebApp scoped feature will work) throw new InvalidOperationException("The AddOnProvidedServiceLocator can only work withing a SPSite's context: i.e. only from SPSite or SPWeb-scoped feature event receivers."); } else { this.EnsureServiceLocatorAccessorForCurrentSiteContext(currentFeatureWeb.Site); // We are dealing with a SPSite or SPWeb-scoped feature. // Always return a web scope (even for Site-scoped features - as being in a site-scoped feature means you are in the RootWeb context) newChildScopeAsNestedAsPossible = this.locatorAccessor.ServiceLocatorInstance.BeginFeatureLifetimeScope(feature); } return newChildScopeAsNestedAsPossible; }
//: this(spParent, feature.Definition, imageIndex, installed) public FeatureNode(object spParent, SPFeature feature, int imageIndex, bool installed) { this.SPParent = spParent; this.ImageIndex = imageIndex; this.SelectedImageIndex = imageIndex; this.IsInstalled = installed; Color nodeColor = this.ForeColor; string addText = string.Empty; try { if (feature.Definition != null) { this.Tag = feature.Definition; if (feature.Definition.Hidden) { nodeColor = Color.DarkGray; addText = " (Hidden)"; } _Text = feature.Definition.GetTitle(SPMConfig.Instance.CultureInfo) + addText; _ToolTip = feature.Definition.GetDescription(SPMConfig.Instance.CultureInfo); _Name = feature.Definition.Id.ToString(); this.ForeColor = nodeColor; } else { this.Tag = null; _Text = SPMLocalization.GetString("Feature_Message01"); _ToolTip = SPMLocalization.GetString("Feature_Message02"); _Name = feature.DefinitionId.ToString(); } } catch(Exception ex) { this.ForeColor = Color.DarkRed; _Text = "(Error: Feature missing)"; _ToolTip = ex.Message; _Name = feature.DefinitionId + string.Empty; } this.Setup(); this.Nodes.Add(new ExplorerNodeBase("Dummy")); }
public static ActivatedFeature ToActivatedFeature(this SPFeature spFeature, Guid parentId, Scope parentScope, string parentUrl) { FeatureDefinition definition = null; bool faulty = false; string definitionInstallationScope = GetDefinitionInstallationScope(spFeature.FeatureDefinitionScope == SPFeatureDefinitionScope.Farm, parentUrl); try { if (spFeature.Definition != null) { var fDef = spFeature.Definition; definition = fDef.ToFeatureDefinition(definitionInstallationScope); } else { definition = FeatureDefinitionFactory.GetFaultyDefinition(spFeature.DefinitionId, parentScope, spFeature.Version, definitionInstallationScope); faulty = true; } } catch (Exception) { faulty = true; } var feature = ActivatedFeatureFactory.GetActivatedFeature( spFeature.DefinitionId, parentId, definition, faulty, spFeature.Properties == null ? null : spFeature.Properties.ToProperties(), spFeature.TimeActivated, spFeature.Version, definitionInstallationScope ); return(feature); }
protected void Button1_Click1(object sender, EventArgs e) { using (SPSite mySite = new SPSite(SPContext.Current.Site.ID)) { Guid featureID = new Guid("6e1e5426-2ebd-4871-8027-c5ca86371ead"); SPFeature feature = mySite.Features[featureID]; if (feature == null) { feature = mySite.Features.Add(featureID); } string p = feature.TimeActivated.ToString() + " " + feature.Definition.Status; //foreach (SPFeatureProperty prop in define.Properties) //{ // p = prop.Name + " " + prop.Value + "-------"; div_Message.InnerHtml += p + "<br/>"; //} } ////#1 //ScriptManager.RegisterStartupScript(this.UpdatePanel1, this.GetType(), "UpdatePanel1", "alert(1)", true); ////#2 //ScriptManager.RegisterStartupScript(this.UpdatePanel2, this.GetType(), "UpdatePanel2", "alert(2)", true); }
private void EnsureWebFeatureActivated(Guid featureGuid, SPSite lSite, SPWeb lWeb) { using (SPSite site = new SPSite(lSite.ID)) { using (SPWeb web = site.OpenWeb(lWeb.ID)) { site.AllowUnsafeUpdates = true; web.AllowUnsafeUpdates = true; SPFeature feature = null; try { feature = web.Features[featureGuid]; } catch { web.Features.Add(featureGuid); } site.AllowUnsafeUpdates = false; web.AllowUnsafeUpdates = false; } } }
public static void UpgradeFeatures(ref SPSite site, Guid featureId) { SPFeatureQueryResultCollection features = null; try { features = site.QueryFeatures(featureId, true); } catch {// not contained } if (features != null) { IEnumerator <SPFeature> featureEnumerator = features.GetEnumerator(); featureEnumerator.Reset(); while (featureEnumerator.MoveNext()) { SPFeature feature = featureEnumerator.Current; feature.Upgrade(false); } } }
public static FeatureParent GetFeatureParent(SPFeature feature, SPFeatureScope scope) { try { if (feature != null && feature.Parent != null && scope != SPFeatureScope.ScopeInvalid) { switch (scope) { case SPFeatureScope.Farm: var f = feature.Parent as SPWebService; // SPWebService.ContentService.Features return(GetFeatureParent(f)); case SPFeatureScope.WebApplication: var wa = feature.Parent as SPWebApplication; return(GetFeatureParent(wa)); case SPFeatureScope.Site: var s = feature.Parent as SPSite; return(GetFeatureParent(s)); case SPFeatureScope.Web: var w = feature.Parent as SPWeb; return(GetFeatureParent(w)); default: return(GetFeatureParentUndefined()); } } else { return(GetFeatureParentUndefined()); } } catch (Exception ex) { return(GetFeatureParentUndefined(ex.Message)); } }
public void AddActivatedFeature(SPFeature feature) { if (feature == null) { return; } try { var activatedFeature = ActivatedFeature.GetActivatedFeature(feature); // update activated features this.ActivatedFeatures.Add(activatedFeature); // update featureDefinition (and its activated instances) var featureDef = this.FeatureDefinitions.FirstOrDefault(fd => fd.Id == activatedFeature.Id); if (featureDef != null) { // add activated feature to feature definition featureDef.ActivatedFeatures.Add(activatedFeature); } else { // fyi - if we get here, we have most likely a group of faulty features ... // create feature definition and add features var newFeatureDef = FeatureDefinition.GetFeatureDefinition(activatedFeature); this.FeatureDefinitions.Add(newFeatureDef); Log.Warning("Unexpected - Feature Definition of activated Feature was not available - please Reload"); } } catch (Exception ex) { Log.Error("Error when trying to add new feature to InMemorySharePointDb", ex); } }
private void AddFeaturesForScope(TreeNode pnode, List <SPFeatureDefinition> fds, SPFeatureCollection active) { TreeNode fnode = new TreeNode("Features", 9, 9); pnode.Nodes.Add(fnode); foreach (SPFeatureDefinition fd in fds) { SPFeature f = active[fd.Id]; TreeNode chnode; if (f == null) { chnode = new TreeNode(fd.DisplayName, 1, 1); } else { chnode = new TreeNode(fd.DisplayName, 0, 0); } chnode.Tag = f; fnode.Nodes.Add(chnode); } }
// Modif JPI - Début protected static void DeactivateFeature(List <SPSite> siteCollections, List <Guid?> featureIds) { try { if (siteCollections != null && featureIds != null && featureIds.Count > 0) { log.Info(res.FeatureDeactivation); foreach (SPSite siteCollection in siteCollections) { foreach (Guid?featureId in featureIds) { if (featureId == null) { continue; } SPFeature feature = siteCollection.Features [featureId.Value]; if (feature == null) { continue; } siteCollection.Features.Remove(featureId.Value); log.Info(siteCollection.Url + " : " + featureId.Value.ToString()); } } } } catch (ArgumentException ex) // Missing assembly in GAC { log.Warn(ex.Message, ex); } catch (InvalidOperationException ex) // Missing receiver class { log.Warn(ex.Message, ex); } catch (SqlException ex) { throw new InstallException(ex.Message, ex); } }
protected internal override bool Execute() { try { // Modif JPI - Début ReadOnlyCollection <Guid?> featureIds = InstallConfiguration.FeatureIdList; if (featureIds != null && featureIds.Count > 0) { foreach (Guid?featureId in featureIds) { if (featureId != null) { SPFeature feature = FeatureActivator.ActivateOneFeature(SPWebService.AdministrationService.Features, featureId.Value, log); } } } return(true); // Modif JPI - Fin } catch (Exception ex) { throw new InstallException(ex.Message, ex); } }
/// <summary> /// Begins the lifetime scope. /// </summary> /// <param name="feature">The feature.</param> /// <returns>A lifetime scope.</returns> public ILifetimeScope BeginLifetimeScope(SPFeature feature) { return InnerServiceLocator.BeginLifetimeScope(feature); }
void rootTable_DataBinding(object sender, EventArgs e) { Table rootTable = (Table)sender; GridViewRow row = (GridViewRow)rootTable.NamingContainer; int itemID = int.Parse(DataBinder.Eval(row.DataItem, Fields.IDField).ToString()); SPFile itemFile = settings.DocumentLibrary.GetItemById(itemID).File; string fileurl = new Uri(new Uri(settings.DocumentLibrary.ParentWeb.Url), String.Format("{0}?ID={1}", settings.DocumentLibrary.Forms[PAGETYPE.PAGE_DISPLAYFORM].ServerRelativeUrl, itemID)).OriginalString; //Bind image controls Image docIconImage = (Image)rootTable.FindControl(DocIconID); string iconUrl = itemFile.IconUrl; docIconImage.ImageUrl = "/_layouts/images/" + iconUrl.TrimStart('/'); //Bind the title link HyperLink titleLink = (HyperLink)rootTable.FindControl(TitleLinkID); titleLink.Text = (String.IsNullOrEmpty(itemFile.Title)) ? itemFile.Name : itemFile.Title; titleLink.NavigateUrl = fileurl; //check if SLK feature is activated to show e-learning action link SPFeature SLKFeature = settings.DocumentLibrary.ParentWeb.Features[new Guid(SLKFeatureID)]; if (SLKFeature != null) { //Bind Actions link HyperLink actionsImage = (HyperLink)rootTable.FindControl(ActionsLinkID); actionsImage.NavigateUrl = String.Format(ELearningActionsUrl, settings.DocumentLibrary.ParentWebUrl.TrimEnd('/'), settings.ListID, itemID); actionsImage.ImageUrl = "/_layouts/SharePointLearningKit/Images/ActionsIcon.gif"; actionsImage.ToolTip = settings.ActionsLinkText; } //Bind the details row if (settings.Keywords.Count > 0) { TableCell detailsCell = (TableCell)rootTable.FindControl(DetailsCellID); IDictionaryEnumerator keywordIterator = settings.Keywords.GetEnumerator(); while (keywordIterator.MoveNext()) { Label keywordLabel = new Label(); string keyword = keywordIterator.Key.ToString(); string fieldTitle = settings.SelectedContentType.Fields.GetFieldByInternalName(keyword).Title; keywordLabel.Text = String.Format("{0}:{1}", fieldTitle, DataBinder.Eval(row.DataItem, keyword).ToString()); detailsCell.Controls.Add(keywordLabel); detailsCell.Controls.Add(new LiteralControl("<BR>")); } } string tempAuthor = String.Empty; string tempSize = String.Empty; string tempdate = string.Empty; if (DataBinder.Eval(row.DataItem, Fields.Created_By).GetType() != typeof(DBNull)) { tempAuthor = " - " + DataBinder.Eval(row.DataItem, Fields.Created_By).ToString(); } if (DataBinder.Eval(row.DataItem, Fields.FileSizeDisplayField).GetType() != typeof(DBNull)) { //format size long sizeInBytes = long.Parse(DataBinder.Eval(row.DataItem, Fields.FileSizeDisplayField).ToString()); tempSize = " - " + SPUtility.FormatSize(sizeInBytes); } if (DataBinder.Eval(row.DataItem, Fields.CreatedField).GetType() != typeof(DBNull)) { DateTime creationDate = DateTime.Parse(DataBinder.Eval(row.DataItem, Fields.CreatedField).ToString()); tempdate = " - " + SPUtility.FormatDate(settings.DocumentLibrary.ParentWeb, creationDate, SPDateFormat.DateOnly); } LiteralControl summaryText = (LiteralControl)rootTable.FindControl(SummaryControlID); summaryText.Text = String.Format(SummaryControlHTML, fileurl, (tempSize + tempAuthor + tempdate)); }
private bool IsFeatureFaulty(SPFeature feature) { if (feature.Definition == null) { return true; } FeatureChecker checker = new FeatureChecker(); if (checker.CheckFeature(feature).Faulty) { return true; } return false; }
public static ActivatedFeature ToActivatedFeature( this SPFeature spFeature, Location location) { FeatureDefinition definition = null; bool faulty = false; string featureUniqueId; string displayName; Version definitionVersion; try { var fDef = spFeature.Definition; if (fDef != null) { if (spFeature.FeatureDefinitionScope == SPFeatureDefinitionScope.Web) { definition = fDef.ToFeatureDefinition(location.UniqueId); } else if (spFeature.FeatureDefinitionScope == SPFeatureDefinitionScope.Site) { if (location.Scope == Scope.Web) { definition = fDef.ToFeatureDefinition(location.ParentId); } else { // only other location with featuredefinitionscope site can be site collection // therefore, location id for sandboxed solution is current location (site) definition = fDef.ToFeatureDefinition(location.UniqueId); } } else { // Featuredefinitionscope must be farm or none now, in both cases, no location will be assigned to feature definition ... definition = fDef.ToFeatureDefinition(null); } featureUniqueId = definition.UniqueIdentifier; displayName = definition.DisplayName; definitionVersion = definition.Version; } else { faulty = true; featureUniqueId = Core.Common.StringHelper.GenerateUniqueId( spFeature.DefinitionId, Core.Common.Constants.Labels.FaultyFeatureCompatibilityLevel ); displayName = Core.Common.Constants.Labels.FaultyFeatureName; definitionVersion = null; } } catch (Exception) { faulty = true; featureUniqueId = Core.Common.StringHelper.GenerateUniqueId( spFeature.DefinitionId, Core.Common.Constants.Labels.FaultyFeatureCompatibilityLevel ); displayName = Core.Common.Constants.Labels.FaultyFeatureName; definitionVersion = null; } var feature = ActivatedFeatureFactory.GetActivatedFeature( featureUniqueId, location.UniqueId, displayName, faulty, spFeature.Properties == null ? null : spFeature.Properties.ToProperties(), spFeature.TimeActivated, spFeature.Version, definitionVersion, spFeature.FeatureDefinitionScope.ToFeatureDefinitionScope() ); return(feature); }
private string GetFeatureSolutionInfo(SPFeature feature) { string text = ""; try { if (feature.Definition != null && feature.Definition.SolutionId != Guid.Empty) { text = string.Format("SolutionId={0}", feature.Definition.SolutionId); SPSolution solution = SPFarm.Local.Solutions[feature.Definition.SolutionId]; if (solution != null) { try { text += string.Format(", SolutionName='{0}'", solution.Name); } catch { } try { text += string.Format(", SolutionDisplayName='{0}'", solution.DisplayName); } catch { } try { text += string.Format(", SolutionDeploymentState='{0}'", solution.DeploymentState); } catch { } } } } catch { } return text; }
/// <summary> /// Creates a new child lifetime scope that is as nested as possible, /// depending on the scope of the specified feature. /// In a SPSite or SPWeb-scoped feature context, will return a web-specific /// lifetime scope (allowing you to inject InstancePerSite and InstancePerWeb /// objects). /// In a SPFarm or SPWebApplication feature context, will return a child /// container of the root application container (preventing you from injecting /// InstancePerSite, InstancePerWeb or InstancePerRequest objects). /// Please dispose this lifetime scope when done (E.G. call this method from /// a using block). /// Prefer usage of this method versus resolving manually from the Current property. /// </summary> /// <param name="feature">The current feature that is requesting a child lifetime scope</param> /// <returns>A new child lifetime scope which should be disposed by the caller.</returns> public static ILifetimeScope BeginLifetimeScope(SPFeature feature) { return(innerLocator.BeginLifetimeScope(feature)); }
/// <summary> /// activate a feature /// </summary> /// <param name="features">collection of features</param> /// <param name="featureId">feature ID of feature to handle</param> /// <param name="force">with or without force</param> /// <returns>the activated feature</returns> /// <remarks>attention, might throw exception!</remarks> internal static SPFeature UpgradeFeatureInFeatureCollection(SPFeatureCollection features, Guid featureId, bool force) { SPFeature spFeature = null; IEnumerable <Exception> upgradeErrors; bool success = true; string upgradeErrorsAsString = null; spFeature = features[featureId]; var definitionVersion = spFeature.Definition.Version; if (spFeature.Version < definitionVersion) { upgradeErrors = spFeature.Upgrade(force); } else { var errMsg = string.Format("Feature '{0}' does not require upgrade.", featureId); throw new ApplicationException(errMsg); } if (upgradeErrors != null && upgradeErrors.Count() > 0) { success = false; foreach (Exception x in upgradeErrors) { upgradeErrorsAsString += string.Format( "Error: {0}\n", x.Message ); } } if (spFeature.Version != definitionVersion || !success) { var errMsg = string.Format("Feature upgrade for feature '{0}' failed. Feature version: '{1}', definition version: '{2}'.", featureId, spFeature.Version, definitionVersion); if (!force) { errMsg += " You might want to try again with 'force' enabled."; } if (!string.IsNullOrEmpty(upgradeErrorsAsString)) { errMsg += upgradeErrorsAsString; } throw new ApplicationException(errMsg); } return(spFeature); }
public static Guid GetFeatureId(this SPFeature feature) { return(feature.Definition.Id); }
/// <summary> /// Ensures the approval workflow on list. /// </summary> /// <param name="web">The web.</param> /// <param name="list">The list.</param> /// <param name="events">The events.</param> /// <param name="useSamlWorkflow">Whether to use the SAML Approval workflow</param> /// <returns> /// The workflow subscription id /// </returns> /// <exception cref="System.ArgumentNullException"></exception> public static Guid EnsureApprovalWorkflowOnList(SPWeb web, SPList list, List <WorkflowStartEventType> events, bool useSamlWorkflow) { Guid subscriptionId = Guid.Empty; if (list == null) { throw new ArgumentNullException("list"); } // Remove existing 2010 workflow associations SPWorkflowAssociationCollection existingWorkflows = list.WorkflowAssociations; if (existingWorkflows != null) { for (int i = 0; i < existingWorkflows.Count; i++) { list.WorkflowAssociations.Remove(existingWorkflows[i]); } } //SPFeature customWorkflowActivitiesFeature = web.Features[customWorkflowActivitiesFeatureId]; //if (customWorkflowActivitiesFeature == null) //{ // customWorkflowActivitiesFeature = web.Features.Add(customWorkflowActivitiesFeatureId); //} SPFeature customWorkflowFeature = web.Features[customWorkflowFeatureId]; if (customWorkflowFeature == null) { customWorkflowFeature = web.Features.Add(customWorkflowFeatureId); } if (customWorkflowFeature != null) { if (!list.EnableModeration || !list.ForceCheckout) { list.EnableModeration = true; list.ForceCheckout = true; list.EnableVersioning = true; list.Update(); } Dictionary <string, string> workflowPropertyData = GetApprovalWorkflowSettings(web, list.Title); SPList taskList = EnsureWorkflowTaskList(web, "/lists/workflowtasks", string.Empty); SPList historyList = EnsureWorkflowHistoryList(web, "/workflowhistory", string.Empty); if (taskList != null && historyList != null) { bool workflowTaskContentTypeAssociated = false; foreach (SPContentType contentType in taskList.ContentTypes) { if (contentType.Parent.Id.ToString().Equals(ContentTypeWorkflowTaskSharePoint2013, StringComparison.OrdinalIgnoreCase)) { workflowTaskContentTypeAssociated = true; break; } } if (!workflowTaskContentTypeAssociated) { SPContentType wftaskContentType = default(SPContentType); SPContentTypeCollection contentTypes = web.ContentTypes.Count == 0 ? web.Site.RootWeb.ContentTypes : web.ContentTypes; wftaskContentType = contentTypes.Cast <SPContentType>().FirstOrDefault <SPContentType>(c => c.Id.ToString().Equals(ContentTypeWorkflowTaskSharePoint2013, StringComparison.OrdinalIgnoreCase)); if (wftaskContentType != null) { taskList.ContentTypes.Add(wftaskContentType); } } string displayName = ResourcesHelper.GetLocalizedString("workflow_approval_instancename"); Guid workflowDefId = useSamlWorkflow ? approvalSamlWorkflowDefinitionId : approvalWorkflowDefinitionId; subscriptionId = EnsureWorkflowOnList(web, list, workflowDefId, displayName, events, taskList, historyList, workflowPropertyData, false); EnableWorkflowsRunAsAnApp(web); SubscribeToEventReceivers(list, false); } } return(subscriptionId); }
/// <summary> /// Creates a new child lifetime scope that is as nested as possible, /// depending on the scope of the specified feature. /// In a SPSite or SPWeb-scoped feature context, will return a web-specific /// lifetime scope (allowing you to inject InstancePerSite and InstancePerWeb /// objects). /// In a SPFarm or SPWebApplication feature context, will return a child /// container of the root application container (preventing you from injecting /// InstancePerSite, InstancePerWeb or InstancePerRequest objects). /// Please dispose this lifetime scope when done (E.G. call this method from /// a using block). /// Prefer usage of this method versus resolving manually from the Current property. /// </summary> /// <param name="feature">The current feature that is requesting a child lifetime scope</param> /// <returns>A new child lifetime scope which should be disposed by the caller.</returns> public static ILifetimeScope BeginFeatureLifetimeScope(SPFeature feature) { return InnerLocator.BeginLifetimeScope(feature); }
protected override void OnLoad(EventArgs e) { base.OnLoad(e); eventType = (PowerEventType)Enum.Parse(typeof(PowerEventType), Request["Type"]); web = SPContext.Current.Web; list = SPContext.Current.List; feature = web.Features[PowerEventReceiversConstants.FeatureId]; switch (eventType) { case PowerEventType.Item: propNameScript = PowerEventReceiversConstants.PowerItemEventReceiverPropNamePrefixScript + list.RootFolder.Url; propNameSequence = PowerEventReceiversConstants.PowerListEventReceiverPropNamePrefixSequence + list.RootFolder.Url; propNameSynchronous = PowerEventReceiversConstants.PowerWebEventReceiverPropNamePrefixSynchronous + list.RootFolder.Url; eventDefinitionType = typeof(PowerItemEventReceiver).FullName; targetName = list.Title; redirectUrl = list.ParentWeb.Url + "/_layouts/listedit.aspx?List=" + HttpUtility.UrlEncode(list.ID.ToString()); break; case PowerEventType.List: propNameScript = PowerEventReceiversConstants.PowerListEventReceiverPropNamePrefixScript + list.RootFolder.Url; propNameSequence = PowerEventReceiversConstants.PowerListEventReceiverPropNamePrefixSequence + list.RootFolder.Url; propNameSynchronous = PowerEventReceiversConstants.PowerWebEventReceiverPropNamePrefixSynchronous + list.RootFolder.Url; eventDefinitionType = typeof(PowerListEventReceiver).FullName; targetName = list.Title; redirectUrl = list.ParentWeb.Url + "/_layouts/listedit.aspx?List=" + HttpUtility.UrlEncode(list.ID.ToString()); break; case PowerEventType.Web: propNameScript = PowerEventReceiversConstants.PowerWebEventReceiverPropNamePrefixScript; propNameSequence = PowerEventReceiversConstants.PowerWebEventReceiverPropNamePrefixScript + web.ID.ToString(); propNameSynchronous = PowerEventReceiversConstants.PowerWebEventReceiverPropNamePrefixSynchronous + web.ID.ToString(); eventDefinitionType = typeof(PowerWebEventReceiver).FullName; targetName = web.Title; redirectUrl = web.Url + "/_layouts/settings.aspx"; break; default: throw new Exception("Unknown event type!"); } scriptProperty = feature.Properties[propNameScript]; sequenceProperty = feature.Properties[propNameSequence]; synchronousProperty = feature.Properties[propNameSynchronous]; if (web.CurrentUser.IsSiteAdmin == false) { throw new SecurityException(); } if (IsPostBack == false) { if (scriptProperty != null) { scriptBox.Text = scriptProperty.Value; } else { switch (eventType) { case PowerEventType.Item: scriptBox.Text = PowerEventReceiversConstants.PowerItemEventReceiverScriptTemplate; break; case PowerEventType.List: scriptBox.Text = PowerEventReceiversConstants.PowerListEventReceiverScriptTemplate; break; case PowerEventType.Web: scriptBox.Text = PowerEventReceiversConstants.PowerWebEventReceiverScriptTemplate; break; default: throw new Exception("Unknown event type!"); } } if (sequenceProperty != null) { sequenceNumber.Text = sequenceProperty.Value; } if (synchronousProperty != null) { checkBoxSynchronous.Checked = Boolean.Parse(synchronousProperty.Value); } } saveButton.Click += new EventHandler(saveButton_Click); cancelButton.Click += new EventHandler(cancelButton_Click); }
/// <summary> /// Creates a new child lifetime scope that is as nested as possible, /// depending on the scope of the specified feature. /// In a SPSite or SPWeb-scoped feature context, will return a web-specific /// lifetime scope (allowing you to inject InstancePerSite and InstancePerWeb /// objects). /// In a SPFarm or SPWebApplication feature context, this method will throw /// an exception of type <see cref="InvalidOperationException"/>. Dynamite components /// must be configured under a specific SPSite's scope. /// Please dispose this lifetime scope when done (E.G. call this method from /// a using block). /// Prefer usage of this method versus resolving individual dependencies from the /// ISharePointServiceLocator.Current property. /// </summary> /// <param name="feature">The current feature that is requesting a child lifetime scope</param> /// <returns>A new child lifetime scope which should be disposed by the caller.</returns> public static ILifetimeScope BeginFeatureLifetimeScope(SPFeature feature) { return extensionProvidedServiceLocator.BeginLifetimeScope(feature); }
protected bool IsFeatureActivated(SPFeature currentFeature) { return currentFeature != null; }
protected bool IsFeatureActivated(SPFeature currentFeature) { return(currentFeature != null); }
/// <summary> /// <para> /// Creates a new child lifetime scope that is as nested as possible, /// depending on the scope of the specified feature. /// </para> /// <para> /// In a SPSite or SPWeb-scoped feature context, will return a web-specific /// lifetime scope (allowing you to inject InstancePerSite and InstancePerWeb /// objects - InstancePerRequest scoped objects will be inaccessible). /// </para> /// <para> /// In a SPFarm or SPWebApplication feature context, will return a child /// container of the root application container (preventing you from injecting /// InstancePerSite, InstancePerWeb or InstancePerRequest objects). /// </para> /// <para> /// If more than 1 assembly matches the *.ServiceLocator.DLL pattern in the GAC, /// store your preferred ServiceLocator assembly name (with key: 'ServiceLocatorAssemblyName') /// in one of the SPPersistedObject's property bags in the SPWeb-SPSite-SPWebApp-SPFarm /// hierarchy to indicate which ServiceLocator should be used in your context. If /// the discriminator setting cannot be found in any of the property bags in the /// hierarchy, an error will be logged to ULS and the FallbackServiceLocator will be used /// (preventing your AddOn registration modules from being loaded). /// </para> /// <para> /// Please dispose this lifetime scope when done (E.G. call this method from /// a using block). /// </para> /// </summary> /// <param name="feature">The current feature context from which we are requesting a child lifetime scope</param> /// <returns>A new child lifetime scope which should be disposed by the caller.</returns> public ILifetimeScope BeginLifetimeScope(SPFeature feature) { SPWeb currentFeatureWeb = feature.Parent as SPWeb; SPSite currentFeatureSite = feature.Parent as SPSite; SPWebApplication currentFeatureWebApp = feature.Parent as SPWebApplication; SPFarm currentFeatureFarm = feature.Parent as SPFarm; if (currentFeatureWeb != null) { this.EnsureServiceLocatorAccessorForCurrentContext(currentFeatureWeb); } else if (currentFeatureSite != null) { this.EnsureServiceLocatorAccessorForCurrentContext(currentFeatureSite); } else if (currentFeatureWebApp != null) { this.EnsureServiceLocatorAccessorForCurrentContext(currentFeatureWebApp); } else if (currentFeatureFarm != null) { this.EnsureServiceLocatorAccessorForCurrentContext(currentFeatureFarm); } else { throw new NotSupportedException("In order to use a lifetime scope, a context (SPWeb, SPSite, SPWebApplication, or SPFarm) needs to be passed."); } return this.GetLocatorAccessor(currentFeatureWeb, currentFeatureSite, currentFeatureWebApp, currentFeatureFarm).ServiceLocatorInstance.BeginLifetimeScope(feature); }
/// <summary> /// Creates a new child lifetime scope that is as nested as possible, /// depending on the scope of the specified feature. /// In a SPSite or SPWeb-scoped feature context, will return a web-specific /// lifetime scope (allowing you to inject InstancePerSite and InstancePerWeb /// objects). /// In a SPFarm or SPWebApplication feature context, will return a child /// container of the root application container (preventing you from injecting /// InstancePerSite, InstancePerWeb or InstancePerRequest objects). /// Please dispose this lifetime scope when done (E.G. call this method from /// a using block). /// Prefer usage of this method versus resolving indididual dependencies from the /// ISharePointServiceLocator.Current property. /// </summary> /// <param name="feature">The current feature that is requesting a child lifetime scope</param> /// <returns>A new child lifetime scope which should be disposed by the caller.</returns> public ILifetimeScope BeginFeatureLifetimeScope(SPFeature feature) { ILifetimeScope newChildScopeAsNestedAsPossible = null; SPSite currentFeatureSite = feature.Parent as SPSite; SPWeb currentFeatureWeb = null; if (currentFeatureSite == null) { // this is a Web-scoped feature, not a Site-scoped one currentFeatureWeb = feature.Parent as SPWeb; } else { // this is a Site-scope feature, use the RootWeb as current currentFeatureWeb = currentFeatureSite.RootWeb; } if (currentFeatureWeb == null) { // We are dealing with a SPWebApplication and SPFarm-scoped feature, so we can // only give you a child lifetime that is a direct child of the root container. // I.E. this service locator/scope won't be able to resolve any InstancePerSite, // InstancePerWeb or InstancePerRequest-registered instances. newChildScopeAsNestedAsPossible = this.containerProvider.Current.BeginLifetimeScope(); } else { // We are dealing with a SPSite or SPWeb-scoped feature. // Always return a web scope (even for Site-scoped features - as being in a site-scoped feature means you are in the RootWeb context) newChildScopeAsNestedAsPossible = this.containerProvider.EnsureWebScope(currentFeatureWeb).BeginLifetimeScope(); } return newChildScopeAsNestedAsPossible; }
private static ActivatedFeature MapSpFeatureToActivatedFeature(SPFeature feature, FeatureParent parent) { var af = GetActivatedFeature(feature, parent); return(af); }
public void InstantiateIn(Control container) { //This table holds all other UI elements for each search result //The table is structure with 3 rows: //* Header row : holds the document icon, title link and E-learning actions //* Details row: holds the details of the fields selected in search //* Summary row: holds the summary infomration about the item such as the full url, size, author and creation date Table rootTable = new Table(); rootTable.CellPadding = 0; rootTable.CellSpacing = 0; TableRow row = new TableRow(); rootTable.Rows.Add(row); TableCell cell = new TableCell(); row.Cells.Add(cell); cell.ColumnSpan = 3; Table headerTable = new Table(); headerTable.CellPadding = 0; headerTable.CellSpacing = 0; headerTable.Width = new Unit(100, UnitType.Percentage); cell.Controls.Add(headerTable); //Create header row TableRow headerRow = new TableRow(); //create header row cells and controls //Doc Icon TableCell docIconCell = new TableCell(); //Holds the document file type icon url Image docIcon = new Image(); docIcon.ID = DocIconID; docIcon.CssClass = Styles.Srch_Icon; docIconCell.Controls.Add(docIcon); headerRow.Cells.Add(docIconCell); //Title link TableCell titleCell = new TableCell(); titleCell.Width = new Unit(100, UnitType.Percentage); HyperLink titleLink = new HyperLink(); titleLink.ID = TitleLinkID; titleLink.CssClass = Styles.Srch_Title; titleCell.Controls.Add(titleLink); headerRow.Cells.Add(titleCell); //E- Learning actions link //check if SLK feature is activated to show e-learning action link SPFeature SLKFeature = settings.DocumentLibrary.ParentWeb.Features[new Guid(SLKFeatureID)]; if (SLKFeature != null) { TableCell actionsCell = new TableCell(); HyperLink actionsLink = new HyperLink(); actionsLink.ID = ActionsLinkID; actionsLink.CssClass = Styles.Srch_Icon; actionsCell.Controls.Add(actionsLink); headerRow.Cells.Add(actionsCell); } headerTable.Rows.Add(headerRow); //Details Row TableRow detailsRow = new TableRow(); rootTable.Rows.Add(detailsRow); //This cell holds the table containg the dynamic list of searched fields TableCell detailsCell = new TableCell(); detailsCell.ID = DetailsCellID; detailsCell.ColumnSpan = 3; detailsCell.CssClass = Styles.Srch_Description; detailsRow.Cells.Add(detailsCell); //Summary row TableRow summaryRow = new TableRow(); rootTable.Rows.Add(summaryRow); //File Link TableCell fileLinkCell = new TableCell(); fileLinkCell.CssClass = Styles.Srch_Metadata; summaryRow.Cells.Add(fileLinkCell); fileLinkCell.ColumnSpan = 3; LiteralControl summaryControl = new LiteralControl(); summaryControl.ID = SummaryControlID; fileLinkCell.Controls.Add(summaryControl); rootTable.DataBinding += new EventHandler(rootTable_DataBinding); container.Controls.Add(rootTable); }
internal static void DoInstallation(Package.InstallationStateData installationStateData, BackgroundWorker _wrkr, DoWorkEventArgs e, FileInfo packageContentLocation) { SPSecurity.RunWithElevatedPrivileges(delegate() { if (_wrkr.CancellationPending) { e.Cancel = true; e.Result = false; return; } try { string _format = "Trying to create or reuse the site collection at {0}, configured site template {1}, LCID {2}."; _wrkr.ReportProgress(1, String.Format(_format, installationStateData.SiteCollectionURL, installationStateData.SiteTemplate, installationStateData.LCID)); using (SiteCollectionHelper m_SiteCollectionHelper = SiteCollectionHelper.GetSPSite( FarmHelpers.WebApplication, installationStateData.SiteCollectionURL, installationStateData.Title, installationStateData.Description, installationStateData.LCID, null, installationStateData.OwnerLogin, installationStateData.OwnerName, installationStateData.OwnerEmail)) { installationStateData.SiteCollectionCreated = true; _wrkr.ReportProgress(1, "Site collection is created"); if (m_SiteCollectionHelper.NewTemplateRequired) { _wrkr.ReportProgress(1, "Applying new template - select required from dialog."); s_EndOFUIAction.Reset(); SPWebTemplateCollection _cllctn = m_SiteCollectionHelper.GetWebTemplates(installationStateData.LCID); _wrkr.ReportProgress(1, new SPWebTeplateEventArgs(_cllctn, GetTemplate, 1, "Getting Site template")); //GetTemplate( FarmHelpers.WebApplication.Sites[ _urlSite ], installationStateData ); s_EndOFUIAction.WaitOne(); _wrkr.ReportProgress(1, String.Format("Applying new template {0}", WebTemplateDialog.SPWebTemplateToString(installationStateData.SPWebTemplate))); m_SiteCollectionHelper.ApplayTemplate(installationStateData.SPWebTemplate); } _format = "The site template is configured to Name: {0}/ Id: {1}."; _wrkr.ReportProgress(1, String.Format(_format, m_SiteCollectionHelper.SiteTemplate, m_SiteCollectionHelper.SiteTemplateID)); using (PackageContent _PackageContent = new PackageContent(packageContentLocation)) { foreach (Solution _sltn in installationStateData.SolutionsToInstall.Values) { FileInfo _fi = _sltn.SolutionFileInfo(_PackageContent.ContentLocation); _wrkr.ReportProgress(1, String.Format("Deploying solution: {0}", _fi.Name)); switch (_sltn.FeatureDefinitionScope) { case FeatureDefinitionScope.Farm: TimeSpan _timeout = new TimeSpan(0, 0, Properties.Settings.Default.SolutionDeploymentTimeOut); string _waitingForCompletion = String.Format("Waiting for completion .... It could take up to {0} s. ", _timeout); _wrkr.ReportProgress(1, _waitingForCompletion); SPSolution _sol = null; if (_sltn.Global) { _sol = FarmHelpers.DeploySolution(_fi, _timeout); } else { _sol = FarmHelpers.DeploySolution(_fi, FarmHelpers.WebApplication, _timeout); } _sltn.SolutionGuid = _sol.Id; _wrkr.ReportProgress(1, String.Format("Solution deployed Name={0}, Deployed={1}, DeploymentState={2}, DisplayName={3} Status={4}", _sol.Name, _sol.Deployed, _sol.DeploymentState, _sol.DisplayName, _sol.Status)); break; case FeatureDefinitionScope.Site: SPUserSolution _solution = null; _solution = m_SiteCollectionHelper.DeploySolution(_fi); _sltn.SolutionGuid = _solution.SolutionId; _wrkr.ReportProgress(1, String.Format("Solution deployed: {0}", _solution.Name)); break; case FeatureDefinitionScope.None: default: throw new ApplicationException("Wrong FeatureDefinitionScope in the configuration file"); } _sltn.Deployed = true; foreach (Feature _fix in _sltn.Fetures) { bool _repeat; do { _repeat = false; try { if (!_fix.AutoActivate) { _wrkr.ReportProgress(1, String.Format("Skipping activation of the feature: {0} at: {1} because tha activation is set false", _fix.FetureGuid, m_SiteCollectionHelper.SiteCollection.Url)); break; } _wrkr.ReportProgress(1, String.Format("Activating Feature: {0} at: {1}", _fix.FetureGuid, m_SiteCollectionHelper.SiteCollection.Url)); SPFeature _ffeature = m_SiteCollectionHelper.ActivateFeature(_fix.FetureGuid, _sltn.SPFeatureDefinitionScope); _wrkr.ReportProgress(1, String.Format("Feature activated : {0}", _ffeature.Definition.DisplayName)); _fix.DisplayName = _ffeature.Definition.DisplayName; _fix.Version = _ffeature.Version.ToString(); _fix.SPScope = _ffeature.Definition.Scope; } catch (Exception ex) { string _msg = String.Format(Properties.Resources.FeatureActivationFailureMBox, ex.Message); Tracing.TraceEvent.TraceError(516, "SetUpData.Install", _msg); switch (MessageBox.Show(_msg, "Install ActivateFeature", MessageBoxButton.YesNoCancel, MessageBoxImage.Error, MessageBoxResult.No)) { case MessageBoxResult.Cancel: throw ex; case MessageBoxResult.Yes: _repeat = true; break; default: break; } } } while (_repeat); }//foreach (Feature _fix in _sltn.Fetures) _sltn.Activated = true; } } //foreach (Solution _sltn //TODO installationStateData.Save(); _wrkr.ReportProgress(1, "Product installation successfully completed"); } } catch (Exception ex) { //TODO //try //{ // installationStateData.Save(); //} //catch ( Exception _SaveEx ) //{ // InstallationListBox.AddMessage( _SaveEx.Message ); //} string _msg = String.Format(Properties.Resources.LastOperationFailedWithError, ex.Message); _wrkr.ReportProgress(1, _msg); throw ex; } }); }
public override void DeployModel(object modelHost, DefinitionBase model) { var definition = model.WithAssertAndCast <FeatureDefinition>("model", value => value.RequireNotNull()); SPFeatureCollection features = null; SPFeature spObject = null; var assert = ServiceFactory.AssertService .NewAssert(definition, spObject); switch (definition.Scope) { case FeatureDefinitionScope.Farm: assert.SkipProperty(m => m.Scope, "Correct farm scope"); var farmModelHost = modelHost.WithAssertAndCast <FarmModelHost>("modelHost", value => value.RequireNotNull()); var farm = farmModelHost.HostFarm; var adminService = SPWebService.AdministrationService; features = adminService.Features; break; case FeatureDefinitionScope.WebApplication: assert.SkipProperty(m => m.Scope, "Correct web app scope"); var webApplicationModelHost = modelHost.WithAssertAndCast <WebApplicationModelHost>("modelHost", value => value.RequireNotNull()); var webApplication = webApplicationModelHost.HostWebApplication; features = webApplication.Features; break; case FeatureDefinitionScope.Site: assert.SkipProperty(m => m.Scope, "Correct site scope"); var siteModelHost = modelHost.WithAssertAndCast <SiteModelHost>("modelHost", value => value.RequireNotNull()); features = siteModelHost.HostSite.Features; break; case FeatureDefinitionScope.Web: assert.SkipProperty(m => m.Scope, "Correct web scope"); var webModelHost = modelHost.WithAssertAndCast <WebModelHost>("modelHost", value => value.RequireNotNull()); features = webModelHost.HostWeb.Features; break; } spObject = GetFeature(features, definition); assert.Dst = spObject; assert .ShouldBeEqual(m => m.Id, o => o.GetFeatureId()); if (definition.ForceActivate) { assert .SkipProperty(m => m.ForceActivate, "ForceActivate = true. Expect not null feature instance.") .ShouldNotBeNull(spObject); } else { assert .SkipProperty(m => m.ForceActivate, "ForceActivate = false. Skipping."); } if (definition.Enable) { assert .SkipProperty(m => m.Enable, "Enable = true. Expect not null feature instance.") .ShouldNotBeNull(spObject); } else { assert .SkipProperty(m => m.Enable, "Enable = false. Expect null feature instance.") .ShouldBeNull(spObject); } }
/// <summary> /// Creates a new child lifetime scope that is as nested as possible, /// depending on the scope of the specified feature. /// /// In a SPSite or SPWeb-scoped feature context, will return a web-specific /// lifetime scope (allowing you to inject InstancePerSite and InstancePerWeb /// objects - InstancePerRequest scoped objects will be inaccessible). /// /// In a SPFarm or SPWebApplication feature context, will return a child /// container of the root application container (preventing you from injecting /// InstancePerSite, InstancePerWeb or InstancePerRequest objects). /// /// If more than 1 assembly matches the *.ServiceLocator.DLL pattern in the GAC, /// store your preferred ServiceLocator assembly name (with key: 'ServiceLocatorAssemblyName') /// in one of the SPPersistedObject's property bags in the SPWeb-SPSite-SPWebApp-SPFarm /// hierarchy to indicate which ServiceLocator should be used in your context. If /// the disambiguator setting cannot be found in any of the property bags in the /// hierarchy, an error will be logged to ULS and the FallbackServiceLocator will be used /// (preventing your AddOn registration modules from being loaded). /// /// Please dispose this lifetime scope when done (E.G. call this method from /// a using block). /// </summary> /// <param name="feature">The current feature context from which we are requesting a child lifetime scope</param> /// <returns>A new child lifetime scope which should be disposed by the caller.</returns> public ILifetimeScope BeginLifetimeScope(SPFeature feature) { SPWeb currentFeatureWeb = feature.Parent as SPWeb; SPSite currentFeatureSite = feature.Parent as SPSite; SPWebApplication currentFeatureWebApp = feature.Parent as SPWebApplication; SPFarm currentFeatureFarm = feature.Parent as SPFarm; if (currentFeatureWeb != null) { this.EnsureServiceLocatorAccessorForCurrentContext(currentFeatureWeb); } else if (currentFeatureSite != null) { this.EnsureServiceLocatorAccessorForCurrentContext(currentFeatureSite); } else if (currentFeatureWebApp != null) { this.EnsureServiceLocatorAccessorForCurrentContext(currentFeatureWebApp); } else if (currentFeatureFarm != null) { this.EnsureServiceLocatorAccessorForCurrentContext(currentFeatureFarm); } else { this.EnsureServiceLocatorAccessorForCurrentContext(); } return this.locatorAccessor.ServiceLocatorInstance.BeginLifetimeScope(feature);; }
/// <summary> /// Generate ActivatedFeature /// </summary> /// <param name="spFeature"></param> /// <param name="parent"></param> /// <returns></returns> public static ActivatedFeature GetActivatedFeature(SPFeature spFeature, FeatureParent parent = null) { if (spFeature == null) { return(null); } // create preliminary feature with default values ... ActivatedFeature af = new ActivatedFeature() { Id = Guid.Empty, Version = new Version("0.0.0.0"), Parent = parent, SharePointFeature = spFeature, Name = "undefined", Faulty = false }; // in case of faulty features, many of these settings can not be set // therefore, every property is set in try / catch statement // ID try { af.Id = spFeature.DefinitionId; } catch (Exception ex) { if (af.Name.Equals("undefined")) { af.Name = ex.Message; } af.Faulty = true; } // Version try { af.TimeActivated = spFeature.TimeActivated; } catch (Exception ex) { if (af.Name.Equals("undefined")) { af.Name = ex.Message; } af.Faulty = true; } // Version try { af.Version = spFeature.Version; } catch (Exception ex) { if (af.Name.Equals("undefined")) { af.Name = ex.Message; } af.Faulty = true; } // Parent try { af.Parent = parent == null?FeatureParent.GetFeatureParent(spFeature) : parent; } catch (Exception ex) { if (af.Name.Equals("undefined")) { af.Name = ex.Message; } af.Faulty = true; } // SharePointFeature is already set on initialization of af // Name try { var def = spFeature.Definition; if (def != null) { af.Name = def.DisplayName; } else { af.Name = string.Format(Common.Constants.Text.UndefinedActivatedFeature, af.Id); af.Faulty = true; } } catch (Exception ex) { if (af.Name.Equals("undefined")) { af.Name = ex.Message; } af.Faulty = true; } return(af); }
protected override void CreateChildControls() { SPView excelView = null; SPList excelList = null; string excelListSchema = String.Empty; spFeatureSite = spSite.Features[Definitions.featureGuid]; if (spFeatureSite != null) { try { //Ziskam vsetky XsltListViewWebPart na stranke ak tam su List <XsltListViewWebPart> xsltListCollection = GetListViewWebParts(); UserPermission userPermission = new UserPermission(); if (xsltListCollection != null) { foreach (XsltListViewWebPart xsltWebPart in xsltListCollection) { SPView currentView = SPContext.Current.Web.Lists[xsltWebPart.ListId].Views[new Guid(xsltWebPart.ViewGuid)]; SPList currentList = SPContext.Current.Web.Lists[xsltWebPart.ListId]; List <SPField> listFieldsInProperties = new List <SPField>(); excelView = currentView; excelList = currentList; //ToDo //Schovanie View tam kde je View pouzite len vo webparzone! //Ak na View nema pravo tak ten control ani nevykresli v pripade ze sa jedna o List tak //sa to osetri v CustomViewSelectorMenu.cs presmerovanom na error page //Nefunguje to pri vyklikanom sposobe vytvorenia listview vo webparzone lebo sa stale vytvara nove VIEW s novym guid if (!viewSelector) { if (userPermission.GetViewPermissionForCurrentUser(currentView)) { xsltWebPart.Hidden = true; continue; } } listFieldsInProperties = FindFieldsInProperties(currentView, currentList); if (listFieldsInProperties != null) { if (listFieldsInProperties.Count != 0) { string newXmlDefinition = HideFieldsInXsltDefinition(listFieldsInProperties, xsltWebPart.XmlDefinition); xsltWebPart.AsyncRefresh = true; xsltWebPart.XmlDefinition = newXmlDefinition; //Toto naplnam pre RenderActiveX prvok excelListSchema = newXmlDefinition; } } } } } catch (Exception ex) { //ToDo } } base.CreateChildControls(); #region - DataSheet - //if (Page.Request.QueryString["ShowInGrid"] == "True") //{ // spFeatureSite = spSite.Features[Definitions.featureGuid]; // if (spFeatureSite != null) // { // if (!excelListSchema.Equals(String.Empty)) // { // try // { // Control controlPlaceHolderMain = this.findControl(this.Page, "PlaceHolderMain"); // if (controlPlaceHolderMain != null) // { // Control controlParent = controlPlaceHolderMain.Parent; // if (controlParent != null) // { // //Schovame stary ActiveX prvok // Literal newStyle = new Literal(); // newStyle.Text = "<style type=\"text/css\">#STSListControlWPQ2{ display:none }</style>"; // controlPlaceHolderMain.Controls.Add(newStyle); // Guid webGuid = spWeb.ID; // Guid listGuid = excelList.ID; // Guid viewGuid = excelView.ID; // string ListData = EncodeString(excelList.Items.Xml); // string ViewSchema = EncodeString(excelListSchema); // string ListSchema = EncodeString(excelList.SchemaXml); // string UrlLink = EncodeString(spWeb.Url); // string csScript = "<script type='text/javascript'>RenderActiveX('\u003cobject id=\u0022STSListControlWPQ3\u0022 name=\u0022STSListControlWPQ3\u0022 classid=CLSID:65BCBEE4-7728-41a0-97BE-14E1CAE36AAE class=\u0022ms-dlgDisable\u0022 width=\u002299\u0025\u0022 tabindex=\u00221\u0022\u003e\u003cparam name=\u0022ListName\u0022 value=\u0022{" + listGuid + "}\u0022\u003e\u003cparam name=\u0022ViewGuid\u0022 value=\u0022{" + viewGuid + "}\u0022\u003e\u003cparam name=\u0022ListWeb\u0022 value=\u0022" + UrlLink + "\u002f_vti_bin\u0022\u003e\u003cparam name=\u0022ListData\u0022 value=\u0022" + ListData + "\u0022\u003e\u003cparam name=\u0022ViewSchema\u0022 value=\u0022" + ViewSchema + "\u0022\u003e\u003cparam name=\u0022ListSchema\u0022 value=\u0022" + ListSchema + "\u0022\u003e\u003cparam name=\u0022ControlName\u0022 value=\u0022STSListControlWPQ3\u0022\u003e\u003cp class=\u0022ms-descriptiontext\u0022\u003eThe Datasheet view of this list cannot be displayed. Please wait while the page is redirected to Standard view. If your list does not appear in a few moments, \u003ca href=\u0022?ShowInGrid=False\u0022 target=_self\u003eopen the list in Standard view\u003c\u002fa\u003e\u003c\u002fp\u003e\u003c\u002fOBJECT\u003e');</script>"; // //Funkcie na ovladanie DataSheetu // string csScriptFunctions = "<script type='text/javascript'>function WPQ2ShowHideTaskPane() { CoreInvoke('GCShowHideTaskPane', document.STSListControlWPQ3 );} function WPQ2ShowHideTotalsRow() { CoreInvoke('GCShowHideTotalsRow', document.STSListControlWPQ3 );} function WPQ2Refresh() { CoreInvoke('GCRefresh', document.STSListControlWPQ3 );} function WPQ2GridNewRow() { CoreInvoke('GCGridNewRow', document.STSListControlWPQ3 );CoreInvoke('GCActivateAndFocus',document.STSListControlWPQ3);} function WPQ2AddColumn() { CoreInvoke('GCAddNewColumn', document.STSListControlWPQ3 , \"" + spWeb.Url + "\" );} function WPQ2ChangeColumn() { CoreInvoke('GCEditDeleteColumn', document.STSListControlWPQ3 , \"" + spWeb.Url + "\" );} function WPQ2GridNewFolder() { CoreInvoke('GCNewFolder', document.STSListControlWPQ3 );}</script> <script type='text/javascript' for='STSListControlWPQ3' event='onresize'>CoreInvoke('GCOnResizeGridControl',document.STSListControlWPQ3);</script> <script type='text/javascript' for='window' event='onresize'>CoreInvoke('GCWindowResize',document.STSListControlWPQ3);</script> <script type='text/javascript'> function _spBodyOnLoad(){CoreInvoke('GCWindowResize',document.STSListControlWPQ3);CoreInvoke('GCActivateAndFocus',document.STSListControlWPQ3);} </script> <script type='text/javascript' for='document' event='onreadystatechange'>if (document.readyState == 'complete') {if (CoreInvoke('TestGCObject', document.STSListControlWPQ3)) { CoreInvoke('GCActivateAndFocus',document.STSListControlWPQ3);} else { CoreInvoke('GCNavigateToNonGridPage'); } }</script>"; // LiteralControl RenderActiveX = new LiteralControl(); // RenderActiveX.Text = csScript + csScriptFunctions; // controlParent.Controls.Add(RenderActiveX); // } // } // } // catch // { // //todo // } // } // } //} #endregion }
public SPFeatureInstance(ObjectInstance prototype, SPFeature feature) : this(prototype) { this.m_feature = feature; }
protected override void OnLoad(EventArgs e) { spFeatureSite = spSite.Features[Definitions.featureGuid]; if (spFeatureSite != null) { try { SPWeb contextWeb = SPControl.GetContextWeb(this.Context); if ((contextWeb != null) && (contextWeb.UIVersion <= 3)) { this._visible = false; return; } Type baseType = this.Page.GetType().BaseType; if ((baseType == typeof(WebPartPage)) || (baseType == typeof(Page))) { Control control = this.findControl(this.Page, "LTViewSelectorMenu"); if (control != null) { if (control.Visible) { viewSelector = true; } } this._visible = true; } #region - Ribbon block functions - //Control control = this.findControl(this.Page, "WebPartWPQ2"); //if (control != null) //{ // //control.Visible = false; //} //WebPartWPQ2 STSListControlWPQ2 //Control control = this.findControl(this.Page, "Ribbon.List.ViewFormat.Datasheet-Large"); //if (control != null) //{ // SPRibbonButton spRibbonDataSheet = control as SPRibbonButton; // spRibbonDataSheet.Enabled = false; //} //Ribbon.List.ViewFormat.Datasheet //SPList.DisableGridEditing //var menuItems = document.getElementsByTagName('ie:menuitem'); //for (i=0; i<menuItems.length; i++) // if (menuItems[i].text == 'Edit in Datasheet') // menuItems[i].removeNode(); //$("ie\\:menuitem[text='Edit in Datasheet']").each(function() //{ this.hidden = true; }); //if this is a System.Web.UI.Page //SPRibbon ribbon = SPRibbon.GetCurrent(this.Page); //ribbon.TrimById("Ribbon.List.Settings.ListPermissions-Large"); //STSListControlWPQ2 //Control control2 = this.findControl(this.Page, "STSListControlWPQ2"); //control2.Visible = false; #endregion } catch { this._visible = false; } } base.OnLoad(e); }
//Dynamicke metody na vytvorenie vlastnosti //protected static GenericSetter set_TemplateContainer_ControlMode = ILUtils.CreateSetMethod(typeof(TemplateContainer), "ControlMode"); //protected static GenericSetter set_TemplateContainer_FieldName = ILUtils.CreateSetMethod(typeof(TemplateContainer), "FieldName"); #endregion #region - Base Methods - protected override void CreateChildControls() { spFeatureSite = spSite.Features[Definitions.featureGuid]; if (spFeatureSite != null) { UserPermission userPermission = new UserPermission(); this.Controls.Clear(); if (this.ControlTemplate == null) { throw new ArgumentException("Could not find ListFieldIterator control template."); } for (int i = 0; i < base.Fields.Count; i++) { SPField field = base.Fields[i]; String fieldName = field.InternalName; if ((!this.IsFieldExcluded(field))) { TemplateContainer child = new TemplateContainer(); this.Controls.Add(child); //Dynamicky vytvorenie metod na nastavenie vlastnosti ControlMode a FieldName //set_TemplateContainer_ControlMode(child, SPControlMode.Display); //set_TemplateContainer_FieldName(child, fieldName); SPUser currentUser = SPContext.Current.Web.CurrentUser; //Zistim nastavenie pre field ci ma byt v Display mode SPControlMode fieldMode; if (formMode != SPControlMode.Display) { if (userPermission.GetFieldPermissionForCurrentUser(field, "ReadOnly", formMode, false, currentUser, null)) { fieldMode = SPControlMode.Display; } else { fieldMode = formMode; } } else { fieldMode = formMode; } //Zadefinovane vlastnosti ControlMode a FieldName priamo cez reflexiu SetFieldName(child, field.InternalName); SetControlMode(child, fieldMode); this.ControlTemplate.InstantiateIn(child); } } } else { base.CreateChildControls(); } }
public static DirectoryInfo Directory(this SPFeature instance) { return(new DirectoryInfo(instance.Definition.RootDirectory)); }
protected void InvokeScript(string eventName, SPWebEventProperties properties) { using (SPSite site = new SPSite(properties.SiteId)) { using (SPWeb web = site.OpenWeb(properties.WebId)) { SPFeature feature = web.Features[PowerEventReceiversConstants.FeatureId]; SPSecurity.RunWithElevatedPrivileges(delegate() { Runspace runspace = RunspaceFactory.CreateRunspace(); runspace.Open(); runspace.SessionStateProxy.SetVariable("httpContext", httpContext); runspace.SessionStateProxy.SetVariable("spContext", spContext); runspace.SessionStateProxy.SetVariable("this", this); runspace.SessionStateProxy.SetVariable("properties", properties); runspace.SessionStateProxy.SetVariable("site", site); runspace.SessionStateProxy.SetVariable("web", web); runspace.SessionStateProxy.SetVariable("user", web.SiteUsers[properties.UserLoginName]); string script = feature.Properties[PowerEventReceiversConstants.PowerWebEventReceiverPropNamePrefixScript].Value; try { Pipeline pipe = runspace.CreatePipeline(PowerEventReceiversConstants.PowerEventReceiversPredefinedFunctions); pipe.Invoke(); pipe = runspace.CreatePipeline(script); pipe.Invoke(); //check if the event's function is defined List <string> functions = PowerEventReceiversHelper.GetFunctions(runspace); if (functions.Contains(eventName.ToLower()) == false) { return; } pipe = runspace.CreatePipeline(eventName); pipe.Invoke(); object objProperties = runspace.SessionStateProxy.GetVariable("properties"); if (objProperties != null) { if (objProperties is PSObject) { properties = (SPWebEventProperties)((PSObject)objProperties).BaseObject; } else { properties = (SPWebEventProperties)objProperties; } } } catch (Exception ex) { try { EventLog.WriteEntry(this.GetType().FullName, ex.Message + "\n" + ex.StackTrace, EventLogEntryType.Error); } catch { } properties.Cancel = true; properties.ErrorMessage = ex.Message; } finally { if (runspace != null && runspace.RunspaceStateInfo.State != RunspaceState.Closed) { runspace.Close(); runspace = null; } } }); } } }
private string DescribeFeatureAndLocation(SPFeature feature) { string location = LocationInfo.SafeDescribeObject(feature.Parent); string msgString = "Faulty Feature found!\n" + string.Format("Id: {0}", feature.DefinitionId); #if SP2013 msgString += " Activation=" + feature.TimeActivated.ToString("yyyy-MM-dd"); #endif string solutionInfo = GetFeatureSolutionInfo(feature); if (!string.IsNullOrEmpty(solutionInfo)) { msgString += solutionInfo; } msgString += Environment.NewLine + string.Format(" Location: {0}\n", location) + string.Format(" Scope: {0}\n", feature.FeatureDefinitionScope) + string.Format(" Version: {0}\n", feature.Version) + " Should it be removed from the farm?"; return msgString; }