linux-packaging-mono/mcs/class/referencesource/System.Web/UI/WebParts/WebPartPersonalization.cs

//------------------------------------------------------------------------------
// <copyright file="WebPartPersonalization.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

namespace System.Web.UI.WebControls.WebParts {

    using System;
    using System.Collections;
    using System.Collections.Specialized;
    using System.ComponentModel;
    using System.Configuration;
    using System.Configuration.Provider;
    using System.Security.Principal;
    using System.Web;
    using System.Web.Configuration;
    using System.Web.UI;
    using System.Web.Util;
    using System.Web.Hosting;

    [TypeConverterAttribute(typeof(EmptyStringExpandableObjectConverter))]
    public class WebPartPersonalization {

        public static readonly WebPartUserCapability ModifyStateUserCapability = new WebPartUserCapability("modifyState");
        public static readonly WebPartUserCapability EnterSharedScopeUserCapability = new WebPartUserCapability("enterSharedScope");

        private WebPartManager _owner;

        // Properties
        private bool _enabled;
        private string _providerName;
        private PersonalizationScope _initialScope;

        // Computed state
        private bool _initialized;
        private bool _initializedSet;
        private PersonalizationProvider _provider;
        private PersonalizationScope _currentScope;
        private IDictionary _userCapabilities;
        private PersonalizationState _personalizationState;
        private bool _scopeToggled;
        private bool _shouldResetPersonalizationState;

        /// <devdoc>
        /// </devdoc>
        public WebPartPersonalization(WebPartManager owner) {
            if (owner == null) {
                throw new ArgumentNullException("owner");
            }

            _owner = owner;

            _enabled = true;
        }

        /// <devdoc>
        /// Indicates whether the current user has the permissions to switch
        /// into shared personalization scope.
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public bool CanEnterSharedScope {
            get {
                // We cannot cache this value, since UserCapabilities is protected virtual,
                // and could return a different value at any time
                IDictionary userCapabilities = UserCapabilities;
                bool canEnterSharedScope = (userCapabilities != null) &&
                    (userCapabilities.Contains(WebPartPersonalization.EnterSharedScopeUserCapability));
                return canEnterSharedScope;
            }
        }

        /// <devdoc>
        /// </devdoc>
        [
        DefaultValue(true),
        NotifyParentProperty(true),
        WebSysDescription(SR.WebPartPersonalization_Enabled)
        ]
        public virtual bool Enabled {
            get {
                return _enabled;
            }
            set {
                if (!WebPartManager.DesignMode && _initializedSet && (value != Enabled)) {
                    throw new InvalidOperationException(
                        SR.GetString(SR.WebPartPersonalization_MustSetBeforeInit, "Enabled", "WebPartPersonalization"));
                }

                _enabled = value;
            }
        }

        // Returns true if the current user in the current scope on the current page has personalization data
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public virtual bool HasPersonalizationState {
            get {
                if (_provider == null) {
                    throw new InvalidOperationException(SR.GetString(SR.WebPartPersonalization_CantUsePropertyBeforeInit,
                                                        "HasPersonalizationState", "WebPartPersonalization"));
                }

                Page page = WebPartManager.Page;
                if (page == null) {
                    throw new InvalidOperationException(SR.GetString(SR.PropertyCannotBeNull, "WebPartManager.Page"));
                }

                HttpRequest request = page.RequestInternal;
                if (request == null) {
                    throw new InvalidOperationException(SR.GetString(SR.PropertyCannotBeNull, "WebPartManager.Page.Request"));
                }

                PersonalizationStateQuery query = new PersonalizationStateQuery();
                query.PathToMatch = request.AppRelativeCurrentExecutionFilePath;
                if (Scope == PersonalizationScope.User && request.IsAuthenticated) {
                    query.UsernameToMatch = page.User.Identity.Name;
                }

                return (_provider.GetCountOfState(Scope, query) > 0);
            }
        }

        /// <devdoc>
        /// Allows changing the initial personalization scope that is given
        /// preference when requesting the page on its first request.
        /// This must be set before personalization data is loaded into the
        /// WebPartManager.
        /// </devdoc>
        [
        DefaultValue(PersonalizationScope.User),
        NotifyParentProperty(true),
        WebSysDescription(SR.WebPartPersonalization_InitialScope)
        ]
        public virtual PersonalizationScope InitialScope {
            get {
                return _initialScope;
            }
            set {
                if ((value < PersonalizationScope.User) || (value > PersonalizationScope.Shared)) {
                    throw new ArgumentOutOfRangeException("value");
                }

                if (!WebPartManager.DesignMode && _initializedSet && (value != InitialScope)) {
                    throw new InvalidOperationException(
                        SR.GetString(SR.WebPartPersonalization_MustSetBeforeInit, "InitialScope", "WebPartPersonalization"));
                }

                _initialScope = value;
            }
        }

        /// <devdoc>
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public bool IsEnabled {
            get {
                return IsInitialized;
            }
        }

        /// <devdoc>
        /// Indicates whether personalization state has been loaded. Properties of this
        /// object cannot be saved once this object is initialized.
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        protected bool IsInitialized {
            get {
                return _initialized;
            }
        }

        /// <devdoc>
        /// Determines if personalization and the ability to modify personalization state is enabled
        /// in the current request. This depends on whether a user is authenticated for this request,
        /// and if that user has the rights to modify personalization state.
        /// To check if just personalization is enabled at all, the IsEnabled property
        /// should be used.
        /// </devdoc>
        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public bool IsModifiable {
            get {
                // We cannot cache this value, since UserCapabilities is protected virtual,
                // and could return a different value at any time
                IDictionary userCapabilities = UserCapabilities;
                bool isModifiable = (userCapabilities != null) &&
                    (userCapabilities.Contains(WebPartPersonalization.ModifyStateUserCapability));
                return isModifiable;
            }
        }

        /// <devdoc>
        /// </devdoc>
        [
        DefaultValue(""),
        NotifyParentProperty(true),
        WebSysDescription(SR.WebPartPersonalization_ProviderName)
        ]
        public virtual string ProviderName {
            get {
                return (_providerName != null) ? _providerName : String.Empty;
            }
            set {
                if (!WebPartManager.DesignMode && _initializedSet &&
                    !String.Equals(value, ProviderName, StringComparison.Ordinal)) {
                    throw new InvalidOperationException(
                        SR.GetString(SR.WebPartPersonalization_MustSetBeforeInit, "ProviderName", "WebPartPersonalization"));
                }

                _providerName = value;
            }
        }

        [
        Browsable(false),
        DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)
        ]
        public PersonalizationScope Scope {
            get {
                return _currentScope;
            }
        }

        internal bool ScopeToggled {
            get {
                return _scopeToggled;
            }
        }

        // True if the personalization data was reset this request.  If so, we will not save data
        // at the end of the request.
        protected bool ShouldResetPersonalizationState {
            get {
                return _shouldResetPersonalizationState;
            }
            set {
                _shouldResetPersonalizationState = value;
            }
        }

        protected virtual IDictionary UserCapabilities {
            get {
                if (_userCapabilities == null) {
                    _userCapabilities = new HybridDictionary();
                }
                return _userCapabilities;
            }
        }

        protected WebPartManager WebPartManager {
            get {
                return _owner;
            }
        }

        /// <devdoc>
        /// </devdoc>
        protected internal virtual void ApplyPersonalizationState() {
            if (IsEnabled) {
                EnsurePersonalizationState();
                _personalizationState.ApplyWebPartManagerPersonalization();
            }
        }

        /// <devdoc>
        /// </devdoc>
        protected internal virtual void ApplyPersonalizationState(WebPart webPart) {
            if (webPart == null) {
                throw new ArgumentNullException("webPart");
            }

            if (IsEnabled) {
                EnsurePersonalizationState();
                _personalizationState.ApplyWebPartPersonalization(webPart);
            }
        }

        // Helper method used by CopyPersonalizationState()
        private void ApplyPersonalizationState(Control control, PersonalizationInfo info) {
            ITrackingPersonalizable trackingPersonalizable = control as ITrackingPersonalizable;
            IPersonalizable customPersonalizable = control as IPersonalizable;

            if (trackingPersonalizable != null) {
                trackingPersonalizable.BeginLoad();
            }

            // If customPersonalizable is null, then info.CustomProperties should also be null
            Debug.Assert(!(customPersonalizable == null && info.CustomProperties != null));

            if (customPersonalizable != null && info.CustomProperties != null && info.CustomProperties.Count > 0) {
                customPersonalizable.Load(info.CustomProperties);
            }

            if (info.Properties != null && info.Properties.Count > 0) {
                BlobPersonalizationState.SetPersonalizedProperties(control, info.Properties);
            }

            if (trackingPersonalizable != null) {
                trackingPersonalizable.EndLoad();
            }
        }

        protected virtual void ChangeScope(PersonalizationScope scope) {
            PersonalizationProviderHelper.CheckPersonalizationScope(scope);

            if (scope == _currentScope) {
                return;
            }

            if ((scope == PersonalizationScope.Shared) && (!CanEnterSharedScope)) {
                throw new InvalidOperationException(SR.GetString(SR.WebPartPersonalization_CannotEnterSharedScope));
            }

            _currentScope = scope;
            _scopeToggled = true;
        }

        // Extracts the personalization state from webPartA, and applies it to webPartB.
        // Assumes that webPartA and webPartB are the same type.  If the WebParts are GenericWebParts,
        // then copies the personalization state from the ChildControl of webPartA to the
        // ChildControl of webPartB.
        protected internal virtual void CopyPersonalizationState(WebPart webPartA, WebPart webPartB) {
            if (webPartA == null) {
                throw new ArgumentNullException("webPartA");
            }
            if (webPartB == null) {
                throw new ArgumentNullException("webPartB");
            }
            if (webPartA.GetType() != webPartB.GetType()) {
                throw new ArgumentException(SR.GetString(SR.WebPartPersonalization_SameType, "webPartA", "webPartB"));
            }

            CopyPersonalizationState((Control)webPartA, (Control)webPartB);

            GenericWebPart genericWebPartA = webPartA as GenericWebPart;
            GenericWebPart genericWebPartB = webPartB as GenericWebPart;
            // Assert that the GenericWebParts are either both null or both non-null
            Debug.Assert((genericWebPartA == null) == (genericWebPartB == null));
            if (genericWebPartA != null && genericWebPartB != null) {
                Control childControlA = genericWebPartA.ChildControl;
                Control childControlB = genericWebPartB.ChildControl;

                if (childControlA == null) {
                    throw new ArgumentException(SR.GetString(SR.PropertyCannotBeNull, "ChildControl"), "webPartA");
                }
                if (childControlB == null) {
                    throw new ArgumentException(SR.GetString(SR.PropertyCannotBeNull, "ChildControl"), "webPartB");
                }
                if (childControlA.GetType() != childControlB.GetType()) {
                    throw new ArgumentException(SR.GetString(SR.WebPartPersonalization_SameType, "webPartA.ChildControl", "webPartB.ChildControl"));
                }

                CopyPersonalizationState(childControlA, childControlB);
            }

            // IPersonalizable.IsDirty should always be false on the new WebPart, since the only data
            // on the new WebPart was loaded via personalization, which should not cause the control
            // to be dirty.  However, we want to save the IPersonalizable data on this request, so
            // we call SetDirty() to force the IPersonalizable data to be saved.
            SetDirty(webPartB);
        }

        private void CopyPersonalizationState(Control controlA, Control controlB) {
            PersonalizationInfo info = ExtractPersonalizationState(controlA);
            ApplyPersonalizationState(controlB, info);
        }

        /// <devdoc>
        /// </devdoc>
        private void DeterminePersonalizationProvider() {
            string providerName = ProviderName;
            if (String.IsNullOrEmpty(providerName)) {
                // Use the default provider
                _provider = PersonalizationAdministration.Provider;
                // The default provider can never be null
                Debug.Assert(_provider != null);
            }
            else {
                // Look for a provider with the specified name
                PersonalizationProvider provider = PersonalizationAdministration.Providers[providerName];
                if (provider != null) {
                    _provider = provider;
                }
                else {
                    throw new ProviderException(
                        SR.GetString(SR.WebPartPersonalization_ProviderNotFound, providerName));
                }
            }
        }

        /// <devdoc>
        /// </devdoc>
        public void EnsureEnabled(bool ensureModifiable) {
            bool value = (ensureModifiable ? IsModifiable : IsEnabled);

            if (!value) {
                string message;
                if (ensureModifiable) {
                    message = SR.GetString(SR.WebPartPersonalization_PersonalizationNotModifiable);
                }
                else {
                    message = SR.GetString(SR.WebPartPersonalization_PersonalizationNotEnabled);
                }
                throw new InvalidOperationException(message);
            }
        }

        private void EnsurePersonalizationState() {
            if (_personalizationState == null) {
                throw new InvalidOperationException(SR.GetString(SR.WebPartPersonalization_PersonalizationStateNotLoaded));
            }
        }

        /// <devdoc>
        /// </devdoc>
        protected internal virtual void ExtractPersonalizationState() {
            // If we reset the personalization data on this request, we should not extract data since
            // it will not be saved.
            if (IsEnabled && !ShouldResetPersonalizationState) {
                EnsurePersonalizationState();
                _personalizationState.ExtractWebPartManagerPersonalization();
            }
        }

        /// <devdoc>
        /// </devdoc>
        protected internal virtual void ExtractPersonalizationState(WebPart webPart) {
            // If we reset the personalization data on this request, we should not extract data since
            // it will not be saved.
            if (IsEnabled && !ShouldResetPersonalizationState) {
                EnsurePersonalizationState();
                _personalizationState.ExtractWebPartPersonalization(webPart);
            }
        }

        // Helper method used by CopyPersonalizationState()
        private PersonalizationInfo ExtractPersonalizationState(Control control) {
            ITrackingPersonalizable trackingPersonalizable = control as ITrackingPersonalizable;
            IPersonalizable customPersonalizable = control as IPersonalizable;

            if (trackingPersonalizable != null) {
                trackingPersonalizable.BeginSave();
            }

            PersonalizationInfo info = new PersonalizationInfo();
            if (customPersonalizable != null) {
                info.CustomProperties = new PersonalizationDictionary();
                customPersonalizable.Save(info.CustomProperties);
            }
            info.Properties = BlobPersonalizationState.GetPersonalizedProperties(control, PersonalizationScope.Shared);

            if (trackingPersonalizable != null) {
                trackingPersonalizable.EndSave();
            }

            return info;
        }

        // Returns the AuthorizationFilter string for a WebPart before it is instantiated
        // Returns null if there is no personalized value for AuthorizationFilter
        protected internal virtual string GetAuthorizationFilter(string webPartID) {
            if (String.IsNullOrEmpty(webPartID)) {
                throw ExceptionUtil.ParameterNullOrEmpty("webPartID");
            }

            EnsureEnabled(false);
            EnsurePersonalizationState();
            return _personalizationState.GetAuthorizationFilter(webPartID);
        }

        /// <devdoc>
        /// </devdoc>
        internal void LoadInternal() {
            if (Enabled) {
                _currentScope = Load();
                _initialized = true;
            }
            _initializedSet = true;
        }

        /// <devdoc>
        /// Loads personalization information from its storage, and computes the initial personalization
        /// scope. This method determines the provider type to be used, and the current user's capabilities.
        /// </devdoc>
        protected virtual PersonalizationScope Load() {
            if (!Enabled) {
                throw new InvalidOperationException(SR.GetString(SR.WebPartPersonalization_PersonalizationNotEnabled));
            }

            // Determine the provider early, as it is needed to continue execution.
            // Provider is used to detect user's capabilities, load personalization state
            // and determine initial scope.
            DeterminePersonalizationProvider();
            Debug.Assert(_provider != null);

            Page page = WebPartManager.Page;
            if (page == null) {
                throw new InvalidOperationException(SR.GetString(SR.PropertyCannotBeNull, "WebPartManager.Page"));
            }

            HttpRequest request = page.RequestInternal;
            if (request == null) {
                throw new InvalidOperationException(SR.GetString(SR.PropertyCannotBeNull, "WebPartManager.Page.Request"));
            }

            // Ask the provider to load information about what are the capabilities of
            // the current user
            if (request.IsAuthenticated) {
                _userCapabilities = _provider.DetermineUserCapabilities(WebPartManager);
            }

            // A derived WebPartPersonalization can have ignoreCurrentUser to be true.
            _personalizationState = _provider.LoadPersonalizationState(WebPartManager, /* ignoreCurrentUser */ false);
            if (_personalizationState == null) {
                // We can't assume that _personalizationState will be non-null, because
                // it depends on the provider implementation.
                throw new ProviderException(SR.GetString(SR.WebPartPersonalization_CannotLoadPersonalization));
            }

            return _provider.DetermineInitialScope(WebPartManager, _personalizationState);
        }

        // Resets the personalization data for the current user in the current scope on the current page
        public virtual void ResetPersonalizationState() {
            EnsureEnabled(/* ensureModifiable */ true);

            if (_provider == null) {
                throw new InvalidOperationException(SR.GetString(SR.WebPartPersonalization_CantCallMethodBeforeInit,
                                                    "ResetPersonalizationState", "WebPartPersonalization"));
            }

            _provider.ResetPersonalizationState(WebPartManager);
            ShouldResetPersonalizationState = true;

            Page page = WebPartManager.Page;
            if (page == null) {
                throw new InvalidOperationException(SR.GetString(SR.PropertyCannotBeNull, "WebPartManager.Page"));
            }

            // Transfer execution to a new instance of the same page.  The new page will execute
            // after personalization data has been reset.
            TransferToCurrentPage(page);
        }

        /// <devdoc>
        /// </devdoc>
        internal void SaveInternal() {
            if (IsModifiable) {
                Save();
            }
        }

        /// <devdoc>
        /// Saves personalization information back to its storage if necessary.
        /// </devdoc>
        protected virtual void Save() {
            EnsureEnabled(/* ensureModifiable */ true);

            EnsurePersonalizationState();

            if (_provider == null) {
                throw new InvalidOperationException(SR.GetString(SR.WebPartPersonalization_CantCallMethodBeforeInit,
                                                    "Save", "WebPartPersonalization"));
            }

            // If we reset the personalization data on this request, we should not save data to the
            // DB on this request.  It is likely we would not save data anyway, since the data probably
            // did not change since the last request, but there are some scenarios where the data could
            // have changed (like a WebPart using personalization as a cache).
            if (_personalizationState.IsDirty && !ShouldResetPersonalizationState) {
                _provider.SavePersonalizationState(_personalizationState);
            }
        }

        /// <devdoc>
        /// </devdoc>
        protected internal virtual void SetDirty() {
            if (IsEnabled) {
                EnsurePersonalizationState();
                _personalizationState.SetWebPartManagerDirty();
            }
        }

        /// <devdoc>
        /// </devdoc>
        protected internal virtual void SetDirty(WebPart webPart) {
            if (IsEnabled) {
                EnsurePersonalizationState();
                _personalizationState.SetWebPartDirty(webPart);
            }
        }

        /// <devdoc>
        /// </devdoc>
        public virtual void ToggleScope() {
            EnsureEnabled(/* ensureModifiable */ false);

            Page page = WebPartManager.Page;
            if (page == null) {
                throw new InvalidOperationException(SR.GetString(SR.PropertyCannotBeNull, "WebPartManager.Page"));
            }
            if (page.IsExportingWebPart) {
                // If the page is exporting, the page determines the desired scope, and it is not meaningful
                // to toggle the scope. Note that we no-op the call, rather than throwing because
                // that would require exposing a CanToggleScope property, require page developers
                // to check for it. Furthermore, we don't guarantee ToggleScope does toggle
                // (eg. in the case of absense of user capability to enter shared scope), so
                // simply no-op'ing isn't terribly bad...
                return;
            }

            Page previousPage = page.PreviousPage;
            if ((previousPage != null) &&
                (previousPage.IsCrossPagePostBack == false)) {
                WebPartManager previousWebPartManager = WebPartManager.GetCurrentWebPartManager(previousPage);

                if ((previousWebPartManager != null) && (previousWebPartManager.Personalization.ScopeToggled)) {
                    // Looks like some sort of infinite recursion is going on
                    // and we're toggling again. Like the previous case, we're
                    // going to no-op and protect ourselves from "----" code...
                    return;
                }
            }

            if (_currentScope == PersonalizationScope.Shared) {
                ChangeScope(PersonalizationScope.User);
            }
            else {
                ChangeScope(PersonalizationScope.Shared);
            }

            // Transfer execution to a new instance of the same page.  The new page will detect the scope
            // it should run in, when it begins to load personalization data.
            TransferToCurrentPage(page);
        }

        // Transfers execution to a new instance of the same page. We need to clear the form collection,
        // since it should not carry over to the page in the new scope (i.e. ViewState). If the form
        // method is GET, then we must not include the query string, since the entire form collection
        // is in the query string.  If the form method is POST (or there is no form), then we must
        // include the query string, since the developer could be using the query string to drive the
        // logic of their page (VSWhidbey 444385 and 527117).
        private void TransferToCurrentPage(Page page) {
            HttpRequest request = page.RequestInternal;
            if (request == null) {
                throw new InvalidOperationException(SR.GetString(SR.PropertyCannotBeNull, "WebPartManager.Page.Request"));
            }

            string path = request.CurrentExecutionFilePath;
            if (page.Form == null || String.Equals(page.Form.Method, "post", StringComparison.OrdinalIgnoreCase)) {
                string queryString = page.ClientQueryString;
                if (!String.IsNullOrEmpty(queryString)) {
                    path += "?" + queryString;
                }
            }

            IScriptManager scriptManager = page.ScriptManager;
            if ((scriptManager != null) && scriptManager.IsInAsyncPostBack) {
                request.Response.Redirect(path);
            }
            else {
                page.Server.Transfer(path, /* preserveForm */ false);
            }
        }

        private sealed class PersonalizationInfo {
            public IDictionary Properties;
            public PersonalizationDictionary CustomProperties;
        }
    }
}