mono/mcs/class/System.Web/System.Web.Profile/ProfileBase.cs

//
// System.Web.UI.WebControls.ProfileBase.cs
//
// Authors:
//	Chris Toshok ([email protected])
//	Vladimir Krasnov ([email protected])
//
// (C) 2005 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System;
using System.Configuration;
using System.Configuration.Provider;
using System.Web.Security;
using System.Web.Configuration;
using System.Reflection;

namespace System.Web.Profile
{
	public class ProfileBase : SettingsBase
	{
		bool _propertiyValuesLoaded = false;
		bool _dirty = false;
		DateTime _lastActivityDate = DateTime.MinValue;
		DateTime _lastUpdatedDate = DateTime.MinValue;
		SettingsContext _settingsContext = null;
		SettingsPropertyValueCollection _propertiyValues = null;
		const string Profiles_SettingsPropertyCollection = "Profiles.SettingsPropertyCollection";

		static SettingsPropertyCollection _properties = null;

		static void InitProperties ()
		{
			SettingsPropertyCollection properties = new SettingsPropertyCollection ();

			ProfileSection config = (ProfileSection) WebConfigurationManager.GetSection ("system.web/profile");
			RootProfilePropertySettingsCollection ps = config.PropertySettings;

			for (int i = 0; i < ps.GroupSettings.Count; i++) {
				ProfileGroupSettings pgs = ps.GroupSettings [i];
				ProfilePropertySettingsCollection ppsc = pgs.PropertySettings;

				for (int s = 0; s < ppsc.Count; s++) {
					SettingsProperty settingsProperty = CreateSettingsProperty (pgs, ppsc [s]);
					ValidateProperty (settingsProperty, ppsc [s].ElementInformation);
					properties.Add (settingsProperty);
				}
			}

			for (int s = 0; s < ps.Count; s++) {
				SettingsProperty settingsProperty = CreateSettingsProperty (null, ps [s]);
				ValidateProperty (settingsProperty, ps [s].ElementInformation);
				properties.Add (settingsProperty);
			}

			if (config.Inherits.Length > 0) {
				Type profileType = ProfileParser.GetProfileCommonType (HttpContext.Current);
				if (profileType != null) {
					Type properiesType = profileType.BaseType;
					for (; ; ) {
						PropertyInfo [] pi = properiesType.GetProperties (BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
						if (pi.Length > 0)
							for (int i = 0; i < pi.Length; i++)
								properties.Add (CreateSettingsProperty (pi [i]));

						if (properiesType.BaseType == null || 
							properiesType.BaseType == typeof (ProfileBase))
							break;

						properiesType = properiesType.BaseType;
					}
				}
			}

			properties.SetReadOnly ();
			lock (Profiles_SettingsPropertyCollection) {
				if (_properties == null)
					_properties = properties;
			}
		}
		
		public ProfileBase ()
		{
		}

		public static ProfileBase Create (string username)
		{
			return Create (username, true);
		}

		public static ProfileBase Create (string username, bool isAuthenticated)
		{
			ProfileBase profile = null;
			Type profileType = ProfileParser.GetProfileCommonType (HttpContext.Current);
			if (profileType != null)
				profile = (ProfileBase) Activator.CreateInstance (profileType);
			else
				profile = (ProfileBase) new DefaultProfile ();

			profile.Initialize (username, isAuthenticated);
			return profile;
		}

		public ProfileGroupBase GetProfileGroup (string groupName)
		{
			ProfileGroupBase group = null;
			Type groupType = ProfileParser.GetProfileGroupType (HttpContext.Current, groupName);
			if (groupType != null)
				group = (ProfileGroupBase) Activator.CreateInstance (groupType);
			else
				throw new ProviderException ("Group '" + groupName + "' not found");

			group.Init (this, groupName);
			return group;
		}

		public object GetPropertyValue (string propertyName)
		{
			if (!_propertiyValuesLoaded)
				InitPropertiesValues ();

			_lastActivityDate = DateTime.UtcNow;

			return ((SettingsPropertyValue) _propertiyValues [propertyName]).PropertyValue;
		}

		public void SetPropertyValue (string propertyName, object propertyValue)
		{
			if (!_propertiyValuesLoaded)
				InitPropertiesValues ();

			if (_propertiyValues [propertyName] == null)
				throw new SettingsPropertyNotFoundException ("The settings property '" + propertyName + "' was not found.");

			if (!(bool)((SettingsPropertyValue) 
				_propertiyValues [propertyName]).Property.Attributes["AllowAnonymous"] && IsAnonymous)
				throw new ProviderException ("This property cannot be set for anonymous users.");

			((SettingsPropertyValue) _propertiyValues [propertyName]).PropertyValue = propertyValue;
			_dirty = true;
			_lastActivityDate = DateTime.UtcNow;
			_lastUpdatedDate = _lastActivityDate;
		}

		public override object this [string propertyName]
		{
			get
			{
				return GetPropertyValue (propertyName);
			}
			set
			{
				SetPropertyValue (propertyName, value);
			}
		}

		void InitPropertiesValues ()
		{
			if (!_propertiyValuesLoaded) {
				_propertiyValues = ProfileManager.Provider.GetPropertyValues (_settingsContext, Properties);
				_propertiyValuesLoaded = true;
			}
		}

		static Type GetPropertyType (ProfileGroupSettings pgs, ProfilePropertySettings pps)
		{
			Type type = HttpApplication.LoadType (pps.Type);
			if (type != null)
				return type;

			Type profileType = null;
			if (pgs == null)
				profileType = ProfileParser.GetProfileCommonType (HttpContext.Current);
			else
				profileType = ProfileParser.GetProfileGroupType (HttpContext.Current, pgs.Name);

			if (profileType == null)
				return null;

			PropertyInfo pi = profileType.GetProperty (pps.Name);
			if (pi != null)
				return pi.PropertyType;

			return null;
		}

		static void ValidateProperty (SettingsProperty settingsProperty, ElementInformation elementInfo)
		{
			string exceptionMessage = string.Empty;
			if (!AnonymousIdentificationModule.Enabled && 
				(bool) settingsProperty.Attributes ["AllowAnonymous"])
				exceptionMessage = "Profile property '{0}' allows anonymous users to store data. " +
					"This requires that the AnonymousIdentification feature be enabled.";

			if (settingsProperty.PropertyType == null)
				exceptionMessage = "The type specified for a profile property '{0}' could not be found.";

			if (settingsProperty.SerializeAs == SettingsSerializeAs.Binary &&
				!settingsProperty.PropertyType.IsSerializable)
				exceptionMessage = "The type for the property '{0}' cannot be serialized " +
					"using the binary serializer, since the type is not marked as serializable.";

			if (exceptionMessage.Length > 0)
				throw new ConfigurationErrorsException (string.Format (exceptionMessage, settingsProperty.Name),
					elementInfo.Source, elementInfo.LineNumber);
		}

		static SettingsProperty CreateSettingsProperty (PropertyInfo property)
		{
			SettingsProperty sp = new SettingsProperty (property.Name);
			Attribute [] attributes = (Attribute [])property.GetCustomAttributes (false);
			SettingsAttributeDictionary attDict = new SettingsAttributeDictionary();
			bool defaultAssigned = false;
			
			sp.SerializeAs = SettingsSerializeAs.ProviderSpecific;
			sp.PropertyType = property.PropertyType;
			sp.IsReadOnly = false;
			sp.ThrowOnErrorDeserializing = false;
			sp.ThrowOnErrorSerializing = true;

			for (int i = 0; i < attributes.Length; i++) {
				if (attributes [i] is DefaultSettingValueAttribute) {
					sp.DefaultValue = ((DefaultSettingValueAttribute) attributes [i]).Value;
					defaultAssigned = true;
				} else if (attributes [i] is SettingsProviderAttribute) {
					Type providerType = HttpApplication.LoadType (((SettingsProviderAttribute) attributes [i]).ProviderTypeName);
					sp.Provider = (SettingsProvider) Activator.CreateInstance (providerType);
					sp.Provider.Initialize (null, null);
				} else if (attributes [i] is SettingsSerializeAsAttribute) {
					sp.SerializeAs = ((SettingsSerializeAsAttribute) attributes [i]).SerializeAs;
				} else if (attributes [i] is SettingsAllowAnonymousAttribute) {
					sp.Attributes ["AllowAnonymous"] = ((SettingsAllowAnonymousAttribute) attributes [i]).Allow;
				} else if (attributes [i] is CustomProviderDataAttribute) {
					sp.Attributes ["CustomProviderData"] = ((CustomProviderDataAttribute) attributes [i]).CustomProviderData;
				} else if (attributes [i] is ApplicationScopedSettingAttribute ||
					   attributes [i] is UserScopedSettingAttribute ||
					   attributes [i] is SettingsDescriptionAttribute  ||
					   attributes [i] is SettingAttribute)
					attDict.Add (attributes [i].GetType (), attributes [i]);
			}

			if (sp.Provider == null)
				sp.Provider = ProfileManager.Provider;

			if (sp.Attributes ["AllowAnonymous"] == null)
				sp.Attributes ["AllowAnonymous"] = false;

			if (!defaultAssigned && sp.PropertyType == typeof (string) && sp.DefaultValue == null)
				sp.DefaultValue = String.Empty;
			
			return sp;
		}
		
		static SettingsProperty CreateSettingsProperty (ProfileGroupSettings pgs, ProfilePropertySettings pps)
		{
			string name = ((pgs == null) ? String.Empty : pgs.Name + ".") + pps.Name;
			SettingsProperty sp = new SettingsProperty (name);

			sp.Attributes.Add ("AllowAnonymous", pps.AllowAnonymous);
			sp.DefaultValue = pps.DefaultValue;
			sp.IsReadOnly = pps.ReadOnly;
			sp.Provider = ProfileManager.Provider;
			sp.ThrowOnErrorDeserializing = false;
			sp.ThrowOnErrorSerializing = true;

			if (pps.Type.Length == 0 || pps.Type == "string")
				sp.PropertyType = typeof (string);
			else
				sp.PropertyType = GetPropertyType (pgs, pps);

			switch (pps.SerializeAs) {
				case SerializationMode.Binary:
					sp.SerializeAs = SettingsSerializeAs.Binary;
					break;
				case SerializationMode.ProviderSpecific:
					sp.SerializeAs = SettingsSerializeAs.ProviderSpecific;
					break;
				case SerializationMode.String:
					sp.SerializeAs = SettingsSerializeAs.String;
					break;
				case SerializationMode.Xml:
					sp.SerializeAs = SettingsSerializeAs.Xml;
					break;
			}

			return sp;
		}


		public void Initialize (string username, bool isAuthenticated)
		{
			_settingsContext = new SettingsContext ();
			_settingsContext.Add ("UserName", username);
			_settingsContext.Add ("IsAuthenticated", isAuthenticated);
			SettingsProviderCollection spc = new SettingsProviderCollection();
			spc.Add (ProfileManager.Provider);
			base.Initialize (Context, ProfileBase.Properties, spc);
		}

		public override void Save ()
		{
			if (IsDirty) {
				ProfileManager.Provider.SetPropertyValues (_settingsContext, _propertiyValues);
			}
		}

		public bool IsAnonymous {
			get {
				return !(bool) _settingsContext ["IsAuthenticated"];
			}
		}

		public bool IsDirty {
			get {
				return _dirty;
			}
		}

		public DateTime LastActivityDate {
			get {
				return _lastActivityDate;
			}
		}

		public DateTime LastUpdatedDate {
			get {
				return _lastUpdatedDate;
			}
		}

		public new static SettingsPropertyCollection Properties {
			get {
				if (_properties == null)
					InitProperties ();

				return _properties;
			}
		}

		public string UserName {
			get {
				return (string) _settingsContext ["UserName"];
			}
		}
	}

}