Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

955 lines
46 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="ClientSettingsProvider.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.ClientServices.Providers
{
using System;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Configuration;
using System.Configuration.Provider;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Security;
using System.Security.Principal;
using System.Security.Permissions;
using System.Net;
using System.ServiceModel;
using System.ServiceModel.Activation;
using System.ServiceModel.Channels;
using System.ServiceModel.Dispatcher;
using System.Web.ClientServices;
using System.Web.Resources;
using System.Web.Security;
using System.Threading;
using System.Data;
using System.Data.Common;
using System.Reflection;
using System.Collections.ObjectModel;
using System.Collections.Generic;
using System.Web.ApplicationServices;
using System.Web.Script.Serialization;
using System.Diagnostics.CodeAnalysis;
[SecurityCritical]
[PermissionSet(SecurityAction.InheritanceDemand, Name="FullTrust")]
public class ClientSettingsProvider : SettingsProvider, IApplicationSettingsProvider
{
private string _ConnectionString = null;
private string _ConnectionStringProvider = "";
private bool _NeedToDoReset = false;
private bool _HonorCookieExpiry = false;
private bool _firstTime = true;
private string _UserName = "";
private SettingsPropertyValueCollection _PropertyValues = new SettingsPropertyValueCollection();
private SettingsPropertyCollection _Properties = null;
private static Hashtable _KnownTypesHashtable = null;
private static Type [] _KnownTypesArray = null;
[SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
public override string ApplicationName {
[SecuritySafeCritical]
get { return ""; }
[SecuritySafeCritical]
set { } }
private static string _ServiceUri = "";
private static object _lock = new object();
private static bool _UsingFileSystemStore = false;
private static bool _UsingIsolatedStore = true;
private static bool _UsingWFCService = false;
private static ApplicationSettingsBase _SettingsBaseClass = null;
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
[SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId="0#", Justification="Reviewed and approved by feature crew"),
SuppressMessage("Microsoft.Security", "CA2116:AptcaMethodsShouldOnlyCallAptcaMethods", Justification="Reviewed and approved by feature crew")]
public static SettingsPropertyCollection GetPropertyMetadata(string serviceUri)
{
CookieContainer cookies = null;
IIdentity id = Thread.CurrentPrincipal.Identity;
SettingsPropertyCollection retColl = new SettingsPropertyCollection();
if (id is ClientFormsIdentity)
cookies = ((ClientFormsIdentity)id).AuthenticationCookies;
if (serviceUri.EndsWith(".svc", StringComparison.OrdinalIgnoreCase)) {
throw new NotImplementedException();
// CustomBinding binding = ProxyHelper.GetBinding();
// ChannelFactory<ProfileService> channelFactory = new ChannelFactory<ProfileService>(binding, new EndpointAddress(serviceUri));
// ProfilePropertyMetadata[] props = null;
// ProfileService clientService = channelFactory.CreateChannel();
// using (new OperationContextScope((IContextChannel)clientService)) {
// ProxyHelper.AddCookiesToWCF(cookies, serviceUri, id.Name, null, null);
// props = clientService.GetPropertiesMetadata();
// ProxyHelper.GetCookiesFromWCF(cookies, serviceUri, id.Name, null, null);
// }
// if (props == null)
// return retColl;
// for(int iter=0; iter<props.Length; iter++) {
// AddToColl(props[iter], retColl, id.IsAuthenticated);
// }
} else {
object o = ProxyHelper.CreateWebRequestAndGetResponse(serviceUri + "/GetPropertiesMetadata",
ref cookies,
id.Name,
null,
null,
null,
null,
typeof(Collection<ProfilePropertyMetadata>));
Collection<ProfilePropertyMetadata> props2 = (Collection<ProfilePropertyMetadata>) o;
if (props2 != null) {
foreach(ProfilePropertyMetadata p in props2)
AddToColl(p, retColl, id.IsAuthenticated);
}
}
return retColl;
}
private static void AddToColl(ProfilePropertyMetadata p, SettingsPropertyCollection retColl, bool isAuthenticated) {
string propName = p.PropertyName;
Type propType = Type.GetType(p.TypeName, false, true);
bool allowAnon = p.AllowAnonymousAccess;
bool readOnly = p.IsReadOnly;
if (!allowAnon && !isAuthenticated)
return;
SettingsSerializeAs serializeAs = (SettingsSerializeAs)p.SerializeAs;
SettingsAttributeDictionary dict = new SettingsAttributeDictionary();
dict.Add("AllowAnonymous", allowAnon);
retColl.Add(new SettingsProperty(propName, propType, null, readOnly,p.DefaultValue, serializeAs, dict, true, true));
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
[SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
[SecuritySafeCritical]
public override void Initialize(string name, NameValueCollection config) {
_UsingIsolatedStore = false;
// Initialize using appSettings section
string temp = System.Configuration.ConfigurationManager.AppSettings["ClientSettingsProvider.ServiceUri"];
if (!string.IsNullOrEmpty(temp))
ServiceUri = temp;
temp = System.Configuration.ConfigurationManager.AppSettings["ClientSettingsProvider.ConnectionStringName"];
if (!string.IsNullOrEmpty(temp)) {
if (ConfigurationManager.ConnectionStrings[temp] != null) {
_ConnectionStringProvider = ConfigurationManager.ConnectionStrings[temp].ProviderName;
_ConnectionString = ConfigurationManager.ConnectionStrings[temp].ConnectionString;
} else {
_ConnectionString = temp;
}
} else {
_ConnectionString = SqlHelper.GetDefaultConnectionString();
}
temp = System.Configuration.ConfigurationManager.AppSettings["ClientSettingsProvider.HonorCookieExpiry"];
if (!string.IsNullOrEmpty(temp))
_HonorCookieExpiry = (string.Compare(temp, "true", StringComparison.OrdinalIgnoreCase) == 0);
if (name == null)
name = this.GetType().ToString();
base.Initialize(name, config);
if (config != null) {
temp = config["serviceUri"];
if (!string.IsNullOrEmpty(temp))
ServiceUri = temp;
temp = config["connectionStringName"];
if (!string.IsNullOrEmpty(temp)) {
if (ConfigurationManager.ConnectionStrings[temp] != null) {
_ConnectionStringProvider = ConfigurationManager.ConnectionStrings[temp].ProviderName;
_ConnectionString = ConfigurationManager.ConnectionStrings[temp].ConnectionString;
} else {
_ConnectionString = temp;
}
}
config.Remove("name");
config.Remove("description");
config.Remove("connectionStringName");
config.Remove("serviceUri");
foreach (string attribUnrecognized in config.Keys)
if (!String.IsNullOrEmpty(attribUnrecognized))
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, AtlasWeb.AttributeNotRecognized, attribUnrecognized));
}
switch(SqlHelper.IsSpecialConnectionString(_ConnectionString))
{
case 1:
_UsingFileSystemStore = true;
break;
case 2:
_UsingIsolatedStore = true;
break;
default:
break;
}
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
[SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
[SecuritySafeCritical]
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection propertyCollection) {
if (propertyCollection == null || propertyCollection.Count < 1)
return new SettingsPropertyValueCollection();
lock(_lock) {
if (_SettingsBaseClass == null && context != null) {
Type oType = context["SettingsClassType"] as Type;
if (oType != null) {
_SettingsBaseClass = oType.InvokeMember("Default", BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Static,
null, null, null, CultureInfo.InvariantCulture) as ApplicationSettingsBase;
}
}
_PropertyValues = new SettingsPropertyValueCollection();
_Properties = propertyCollection;
StoreKnownTypes(propertyCollection);
GetPropertyValuesCore();
return _PropertyValues;
}
}
private void GetPropertyValuesCore()
{
_UserName = Thread.CurrentPrincipal.Identity.Name;
if (_firstTime) {
_firstTime = false;
_NeedToDoReset = GetNeedToReset();
RegisterForValidateUserEvent();
}
if (_NeedToDoReset) {
_NeedToDoReset = false;
SetNeedToReset(false);
_PropertyValues = new SettingsPropertyValueCollection();
SetRemainingValuesToDefault();
SetPropertyValuesCore(_PropertyValues, false);
}
bool isCacheMoreFresh = GetIsCacheMoreFresh();
GetPropertyValuesFromSQL(); // Always start with the local copy
if (!ConnectivityStatus.IsOffline) {
if (isCacheMoreFresh) {
SetPropertyValuesWeb(_PropertyValues, isCacheMoreFresh); // local copy is fresher, so update the web-copy
} else {
GetPropertyValuesFromWeb();
SetPropertyValuesSQL(_PropertyValues, false);
}
}
if (_PropertyValues.Count < _Properties.Count)
SetRemainingValuesToDefault();
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
[SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
[SecuritySafeCritical]
public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection propertyValueCollection) {
if (propertyValueCollection == null || propertyValueCollection.Count < 1)
return;
lock(_lock) {
StoreKnownTypes(propertyValueCollection);
SetPropertyValuesCore(propertyValueCollection, true);
}
}
private void SetPropertyValuesCore(SettingsPropertyValueCollection values, bool raiseEvent) {
lock(_lock) {
bool isCacheMoreFresh = GetIsCacheMoreFresh();
// First store in SQL
SetPropertyValuesSQL(values, true);
Collection<string> errorList = null;
// Store in web if it is offline
if (!ConnectivityStatus.IsOffline)
errorList = SetPropertyValuesWeb(values, isCacheMoreFresh);
if (raiseEvent && SettingsSaved != null) {
if (errorList == null)
errorList = new Collection<string>();
SettingsSaved(this, new SettingsSavedEventArgs(errorList));
}
}
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
[SecuritySafeCritical]
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
public void Reset(SettingsContext context) {
lock(_lock) {
if (_Properties == null) {
SetNeedToReset(true);
} else {
_PropertyValues = new SettingsPropertyValueCollection();
SetRemainingValuesToDefault();
SetPropertyValues(context, _PropertyValues);
_NeedToDoReset = false;
SetNeedToReset(false);
}
}
}
[SecuritySafeCritical]
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
public void Upgrade(SettingsContext context, SettingsPropertyCollection properties) {
return;
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
[SecuritySafeCritical]
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2123:OverrideLinkDemandsShouldBeIdenticalToBase")]
public SettingsPropertyValue GetPreviousVersion(SettingsContext context, SettingsProperty property) {
if (_Properties == null)
_Properties = new SettingsPropertyCollection();
if (_Properties[property.Name] == null)
_Properties.Add(property);
GetPropertyValuesCore();
return _PropertyValues[property.Name];
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
private string GetServiceUri()
{
if (string.IsNullOrEmpty(_ServiceUri))
throw new ArgumentException(AtlasWeb.ServiceUriNotFound);
return _ServiceUri;
}
[SuppressMessage("Microsoft.Design", "CA1056:UriPropertiesShouldNotBeStrings", Justification = "Reviewed and approved by feature crew")]
public static string ServiceUri
{
[SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "2#", Justification = "Reviewed and approved by feature crew")]
get
{
return _ServiceUri;
}
[SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "2#", Justification = "Reviewed and approved by feature crew")]
set {
_ServiceUri = value;
if (string.IsNullOrEmpty(_ServiceUri)) {
_UsingWFCService = false;
} else {
_UsingWFCService = _ServiceUri.EndsWith(".svc", StringComparison.OrdinalIgnoreCase);
}
}
}
public event EventHandler<SettingsSavedEventArgs> SettingsSaved;
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
internal static Type[] GetKnownTypes(ICustomAttributeProvider knownTypeAttributeTarget)
{
if (_KnownTypesArray == null)
InitKnownTypes();
return _KnownTypesArray;
}
static private void InitKnownTypes()
{
_KnownTypesHashtable = new Hashtable();
_KnownTypesArray = new Type[]{ typeof(bool),
typeof(string),
typeof(ArrayList),
typeof(ProfilePropertyMetadata),
typeof(IDictionary<string, object>),
typeof(Collection<string>)
};
for(int iter=0; iter<_KnownTypesArray.Length; iter++)
_KnownTypesHashtable.Add(_KnownTypesArray[iter], string.Empty);
}
static private void StoreKnownTypes(SettingsPropertyValueCollection propertyValueCollection)
{
if (_KnownTypesHashtable == null)
InitKnownTypes();
ArrayList al = null;
foreach(SettingsPropertyValue p in propertyValueCollection) {
if (!_KnownTypesHashtable.Contains(p.Property.PropertyType)) {
_KnownTypesHashtable.Add(p.Property.PropertyType, string.Empty);
if (al == null)
al = new ArrayList();
al.Add(p.Property.PropertyType);
}
}
if (al != null) {
Type [] temp = new Type[_KnownTypesArray.Length + al.Count];
_KnownTypesArray.CopyTo(temp, 0);
al.CopyTo(temp, _KnownTypesArray.Length);
_KnownTypesArray = temp;
}
}
static private void StoreKnownTypes(SettingsPropertyCollection propertyCollection)
{
if (_KnownTypesHashtable == null)
InitKnownTypes();
ArrayList al = null;
foreach(SettingsProperty p in propertyCollection) {
if (!_KnownTypesHashtable.Contains(p.PropertyType)) {
_KnownTypesHashtable.Add(p.PropertyType, string.Empty);
if (al == null)
al = new ArrayList();
al.Add(p.PropertyType);
}
}
if (al != null) {
Type [] temp = new Type[_KnownTypesArray.Length + al.Count];
_KnownTypesArray.CopyTo(temp, 0);
al.CopyTo(temp, _KnownTypesArray.Length);
_KnownTypesArray = temp;
}
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
private void GetPropertyValuesFromWeb()
{
GetPropertyValuesFromWebCore(_HonorCookieExpiry);
// Any failures?
bool anyFailures = (_PropertyValues.Count < _Properties.Count);
if (!_HonorCookieExpiry && anyFailures) {
// if there were failures, try re-validating the ClientFormsIdentity
// and try again
ClientFormsIdentity id = Thread.CurrentPrincipal.Identity as ClientFormsIdentity;
if (id != null) {
id.RevalidateUser();
GetPropertyValuesFromWebCore(true);
}
}
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
[SuppressMessage("Microsoft.Security", "CA2116:AptcaMethodsShouldOnlyCallAptcaMethods", Justification="Reviewed and approved by feature crew")]
private void GetPropertyValuesFromWebCore(bool bubbleExceptionFromSvc) {
string [] propertyNames = new string[_Properties.Count];
int iter = 0;
CookieContainer cookies = null;
IIdentity id = Thread.CurrentPrincipal.Identity;
foreach (SettingsProperty setting in _Properties) {
propertyNames[iter++] = setting.Name;
}
if (id is ClientFormsIdentity)
cookies = ((ClientFormsIdentity)id).AuthenticationCookies;
if (_UsingWFCService) {
throw new NotImplementedException();
// CustomBinding binding = ProxyHelper.GetBinding();
// ChannelFactory<ProfileService> channelFactory = new ChannelFactory<ProfileService>(binding, new EndpointAddress(GetServiceUri()));
// ProfileService clientService = channelFactory.CreateChannel();
// Dictionary<string, object> propertyValues = null;
// using (new OperationContextScope((IContextChannel)clientService)) {
// ProxyHelper.AddCookiesToWCF(cookies, GetServiceUri(), id.Name, GetConnectionString(), _ConnectionStringProvider);
// propertyValues = clientService.GetPropertiesForCurrentUser(propertyNames, id.IsAuthenticated && (id is ClientFormsIdentity));
// ProxyHelper.GetCookiesFromWCF(cookies, GetServiceUri(), id.Name, GetConnectionString(), _ConnectionStringProvider);
// }
// for(iter = 0; iter<propertyNames.Length; iter++) {
// string name = propertyNames[iter];
// if (!propertyValues.ContainsKey(name))
// continue;
// SettingsProperty setting = _Properties[name];
// if (setting == null)
// continue; // Bad -- why wasn't it found?
// bool mustAdd = false;
// SettingsPropertyValue value = _PropertyValues[setting.Name];
// if (value == null) {
// value = new SettingsPropertyValue(setting);
// mustAdd = true;
// }
// //if ((value.SerializedValue is string) && ((string)value.SerializedValue == "(null)")) {
// value.PropertyValue = propertyValues[name];
// value.Deserialized = true;
// // } else if (setting.SerializeAs == SettingsSerializeAs.Binary)
// // value.SerializedValue = Convert.FromBase64String(propertyValues[iter]);
// // else
// // value.SerializedValue = propertyValues[iter];
// // value.Deserialized = false;
// value.IsDirty = false;
// if (mustAdd)
// _PropertyValues.Add(value);
// }
} else {
string [] paramNames = new string [] {"properties", "authenticatedUserOnly" };
object [] paramValues = new object [] {propertyNames, id.IsAuthenticated && (id is ClientFormsIdentity) };
object obj = null;
try {
obj = ProxyHelper.CreateWebRequestAndGetResponse(
GetServiceUri() + "/GetPropertiesForCurrentUser",
ref cookies,
id.Name,
_ConnectionString,
_ConnectionStringProvider,
paramNames,
paramValues,
typeof(Dictionary<string, object>));
} catch {
if (bubbleExceptionFromSvc)
throw;
}
if (obj != null) {
Dictionary<string, object> ret = (Dictionary<string, object>) obj;
foreach(KeyValuePair<string,object> de in ret) {
SettingsProperty setting = _Properties[(string) de.Key];
if (setting == null)
continue; // Bad -- why wasn't it found?
bool mustAdd = false;
SettingsPropertyValue value = _PropertyValues[setting.Name];
if (value == null) {
value = new SettingsPropertyValue(setting);
mustAdd = true;
}
if (de.Value != null && !setting.PropertyType.IsAssignableFrom(de.Value.GetType()))
{
object convertedValue = null;
if (!ObjectConverter.TryConvertObjectToType(de.Value,
setting.PropertyType,
new JavaScriptSerializer(),
out convertedValue))
{
// Failure to convert!
continue;
}
value.PropertyValue = convertedValue;
} else {
value.PropertyValue = de.Value;
}
value.Deserialized = true;
value.IsDirty = false;
if (mustAdd)
_PropertyValues.Add(value);
}
}
}
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
private Collection<string> SetPropertyValuesWeb(SettingsPropertyValueCollection values, bool cacheIsMoreFresh)
{
bool anyFailures = false;
Collection<string> errorList = null;
ClientFormsIdentity id = Thread.CurrentPrincipal.Identity as ClientFormsIdentity;
try {
errorList = SetPropertyValuesWebCore(values, cacheIsMoreFresh);
anyFailures = (errorList != null && errorList.Count > 0);
}
catch (WebException) {
if (id == null || _HonorCookieExpiry) {
throw;
}
anyFailures = true;
}
if (!_HonorCookieExpiry && anyFailures) {
// if there were failures, try re-validating the ClientFormsIdentity
// and try again
if (id != null) {
id.RevalidateUser();
errorList = SetPropertyValuesWebCore(values, cacheIsMoreFresh);
}
}
return errorList;
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
[SuppressMessage("Microsoft.Security", "CA2116:AptcaMethodsShouldOnlyCallAptcaMethods", Justification="Reviewed and approved by feature crew")]
private Collection<string> SetPropertyValuesWebCore(SettingsPropertyValueCollection values, bool cacheIsMoreFresh)
{
Dictionary<string, object> propertyValues = new Dictionary<string, object>();
Collection<string> errorList = null;
foreach(SettingsPropertyValue value in values) {
if (cacheIsMoreFresh || value.IsDirty) {
propertyValues.Add(value.Property.Name, value.PropertyValue);
}
}
CookieContainer cookies = null;
IIdentity id = Thread.CurrentPrincipal.Identity;
if (id is ClientFormsIdentity)
cookies = ((ClientFormsIdentity)id).AuthenticationCookies;
if (_UsingWFCService) {
throw new NotImplementedException();
// CustomBinding binding = ProxyHelper.GetBinding();
// ChannelFactory<ProfileService> channelFactory = new ChannelFactory<ProfileService>(binding, new EndpointAddress(GetServiceUri()));
// ProfileService clientService = channelFactory.CreateChannel();
// using (new OperationContextScope((IContextChannel)clientService)) {
// ProxyHelper.AddCookiesToWCF(cookies, GetServiceUri(), id.Name, GetConnectionString(), _ConnectionStringProvider);
// errorList = clientService.SetPropertiesForCurrentUser(propertyValues, id.IsAuthenticated && (id is ClientFormsIdentity));
// ProxyHelper.GetCookiesFromWCF(cookies, GetServiceUri(), id.Name, GetConnectionString(), _ConnectionStringProvider);
// }
} else {
// Collection<string> SetPropertiesForCurrentUser(IDictionary<string, object> values, bool authenticatedUserOnly)
string [] paramNames = new string [] {"values", "authenticatedUserOnly" };
object [] paramValues = new object [] {propertyValues, id.IsAuthenticated && (id is ClientFormsIdentity) };
object o = ProxyHelper.CreateWebRequestAndGetResponse(GetServiceUri() + "/SetPropertiesForCurrentUser",
ref cookies,
id.Name,
_ConnectionString,
_ConnectionStringProvider,
paramNames,
paramValues,
typeof(Collection<string>));
errorList = (Collection<string>) o;
}
SetIsCacheMoreFresh(false);
return errorList;
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
private void GetPropertyValuesFromSQL()
{
if (_UsingFileSystemStore || _UsingIsolatedStore)
{
ClientData cd = ClientDataManager.GetUserClientData(Thread.CurrentPrincipal.Identity.Name, _UsingIsolatedStore);
if (cd.SettingsNames == null || cd.SettingsValues == null)
return;
int len = cd.SettingsNames.Length;
if (cd.SettingsNames.Length != cd.SettingsStoredAs.Length || cd.SettingsValues.Length != cd.SettingsStoredAs.Length)
{
return; // Bad!
}
for(int iter=0; iter<len; iter++) {
AddProperty(cd.SettingsNames[iter], cd.SettingsStoredAs[iter], cd.SettingsValues[iter]);
}
return;
}
using (DbConnection conn = SqlHelper.GetConnection(Thread.CurrentPrincipal.Identity.Name,
GetConnectionString(), _ConnectionStringProvider))
{
DbTransaction trans = null;
try {
trans = conn.BeginTransaction();
DbCommand cmd = conn.CreateCommand();
cmd.CommandText = "SELECT PropertyName, PropertyStoredAs, PropertyValue FROM Settings";
cmd.Transaction = trans;
using(DbDataReader reader = cmd.ExecuteReader()) {
while(reader.Read()) {
string name = reader.GetString(0);
string storedAs = reader.GetString(1);
string propVal = (reader.IsDBNull(2) ? null : reader.GetString(2));
AddProperty(name, storedAs, propVal);
}
}
} catch {
if (trans != null) {
trans.Rollback();
trans = null;
}
throw;
} finally {
if (trans != null)
trans.Commit();
}
}
}
private void AddProperty(string name, string storedAs, string propVal)
{
if (storedAs != "S" && storedAs != "B" && storedAs != "N")
return;
SettingsProperty prop = _Properties[name];
if (prop == null)
return;
SettingsPropertyValue value = _PropertyValues[name];
bool mustAdd = false;
if (value == null) {
value = new SettingsPropertyValue(prop);
mustAdd = true;
}
switch(storedAs) {
case "S":
value.SerializedValue = propVal;
break;
case "B":
value.SerializedValue = Convert.FromBase64String(propVal);
break;
case "N":
value.SerializedValue = null;
break;
}
value.Deserialized = false;
value.IsDirty = false;
if (mustAdd)
_PropertyValues.Add(value);
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
private void SetPropertyValuesSQL(SettingsPropertyValueCollection values, bool updateSaveTime)
{
string username = Thread.CurrentPrincipal.Identity.Name;
if (_UsingFileSystemStore || _UsingIsolatedStore)
{
ClientData cd = ClientDataManager.GetUserClientData(username, _UsingIsolatedStore);
cd.SettingsNames = new string[values.Count];
cd.SettingsStoredAs = new string[values.Count];
cd.SettingsValues = new string[values.Count];
int iter=0;
foreach(SettingsPropertyValue value in values) {
cd.SettingsNames[iter] = value.Property.Name;
object val = value.SerializedValue;
if (val == null) {
cd.SettingsStoredAs[iter] = "N";
} else if (val is string) {
cd.SettingsStoredAs[iter] = "S";
cd.SettingsValues[iter] = (string) val;
} else {
cd.SettingsStoredAs[iter] = "B";
cd.SettingsValues[iter] = Convert.ToBase64String((byte[])val);
}
iter++;
}
if (updateSaveTime)
cd.SettingsCacheIsMoreFresh = true;
cd.Save();
return;
}
using (DbConnection conn = SqlHelper.GetConnection(username, GetConnectionString(), _ConnectionStringProvider)) {
DbTransaction trans = null;
try {
trans = conn.BeginTransaction();
foreach(SettingsPropertyValue value in values) {
DbCommand cmd = conn.CreateCommand();
cmd.Transaction = trans;
cmd.CommandText = "DELETE FROM Settings WHERE PropertyName = @PropName";
SqlHelper.AddParameter(conn, cmd, "@PropName", value.Property.Name);
cmd.ExecuteNonQuery();
cmd = conn.CreateCommand();
cmd.Transaction = trans;
object val = value.SerializedValue;
if (val == null) {
cmd.CommandText = "INSERT INTO Settings (PropertyName, PropertyStoredAs, PropertyValue) VALUES (@PropName, 'N', '')";
SqlHelper.AddParameter(conn, cmd, "@PropName", value.Property.Name);
} else if (val is string) {
cmd.CommandText = "INSERT INTO Settings (PropertyName, PropertyStoredAs, PropertyValue) VALUES (@PropName, 'S', @PropVal)";
SqlHelper.AddParameter(conn, cmd, "@PropName", value.Property.Name);
SqlHelper.AddParameter(conn, cmd, "@PropVal", (string) val);
} else {
cmd.CommandText = "INSERT INTO Settings (PropertyName, PropertyStoredAs, PropertyValue) VALUES (@PropName, 'B', @PropVal)";
SqlHelper.AddParameter(conn, cmd, "@PropName", value.Property.Name);
SqlHelper.AddParameter(conn, cmd, "@PropVal", Convert.ToBase64String((byte[])val));
}
cmd.ExecuteNonQuery();
}
} catch {
if (trans != null) {
trans.Rollback();
trans = null;
}
throw;
} finally {
if (trans != null)
trans.Commit();
}
}
if (updateSaveTime)
SetIsCacheMoreFresh(true);
}
private bool GetNeedToReset()
{
if (_UsingFileSystemStore || _UsingIsolatedStore) {
ClientData cd = ClientDataManager.GetUserClientData(Thread.CurrentPrincipal.Identity.Name, _UsingIsolatedStore);
return cd.SettingsNeedReset;
} else {
string temp = GetTagValue("NeeedToDoReset");
return (temp != null && temp == "1");
}
}
private void SetNeedToReset(bool fSet)
{
if (_UsingFileSystemStore || _UsingIsolatedStore) {
ClientData cd = ClientDataManager.GetUserClientData(Thread.CurrentPrincipal.Identity.Name, _UsingIsolatedStore);
cd.SettingsNeedReset = fSet;
cd.Save();
} else {
SetTagValue("NeeedToDoReset", fSet ? "1" : "0");
}
}
private bool GetIsCacheMoreFresh()
{
if (_UsingFileSystemStore || _UsingIsolatedStore) {
ClientData cd = ClientDataManager.GetUserClientData(Thread.CurrentPrincipal.Identity.Name, _UsingIsolatedStore);
return cd.SettingsCacheIsMoreFresh;
} else {
string temp = GetTagValue("IsCacheMoreFresh");
return (temp != null && temp == "1");
}
}
private void SetIsCacheMoreFresh(bool fSet)
{
if (_UsingFileSystemStore || _UsingIsolatedStore) {
ClientData cd = ClientDataManager.GetUserClientData(Thread.CurrentPrincipal.Identity.Name, _UsingIsolatedStore);
cd.SettingsCacheIsMoreFresh = fSet;
cd.Save();
} else {
SetTagValue("IsCacheMoreFresh", fSet ? "1" : "0");
}
}
private string GetTagValue(string tagName)
{
string username = Thread.CurrentPrincipal.Identity.Name;
using (DbConnection conn = SqlHelper.GetConnection(username, GetConnectionString(), _ConnectionStringProvider))
{
DbCommand cmd = conn.CreateCommand();
cmd.CommandText = @"SELECT PropertyValue FROM Settings WHERE PropertyName = @PropName AND PropertyStoredAs='I'";
SqlHelper.AddParameter(conn, cmd, "@PropName", tagName);
return cmd.ExecuteScalar() as string;
}
}
private void SetTagValue(string tagName, string tagValue)
{
string username = Thread.CurrentPrincipal.Identity.Name;
using (DbConnection conn = SqlHelper.GetConnection(username, GetConnectionString(), _ConnectionStringProvider)) {
DbCommand cmd = conn.CreateCommand();
cmd.CommandText = @"DELETE FROM Settings WHERE PropertyName = @PropName AND PropertyStoredAs='I'";
SqlHelper.AddParameter(conn, cmd, "@PropName", tagName);
cmd.ExecuteNonQuery();
if (tagValue != null) {
cmd = conn.CreateCommand();
cmd.CommandText = @"INSERT INTO Settings (PropertyName, PropertyStoredAs, PropertyValue) VALUES (@PropName, 'I', @PropValue)";
SqlHelper.AddParameter(conn, cmd, "@PropName", tagName);
SqlHelper.AddParameter(conn, cmd, "@PropValue", tagValue);
cmd.ExecuteNonQuery();
}
}
}
private void RegisterForValidateUserEvent()
{
foreach(MembershipProvider provider in Membership.Providers) {
EventInfo ei = provider.GetType().GetEvent("UserValidated");
if (ei == null)
continue;
MethodInfo addMethod = ei.GetAddMethod();
if (addMethod == null)
continue;
ParameterInfo[] addMethodParams = addMethod.GetParameters();
Delegate handlerDelegate = Delegate.CreateDelegate(addMethodParams[0].ParameterType, this, "OnUserValidated");
addMethod.Invoke(provider, new Object[1]{handlerDelegate});
}
}
[SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification="Called via Reflection")]
private void OnUserValidated(object src, UserValidatedEventArgs e)
{
_NeedToDoReset = GetNeedToReset();
if (_Properties != null && _Properties.Count > 0 && string.Compare(e.UserName, _UserName, StringComparison.OrdinalIgnoreCase) != 0) {
try {
if (_SettingsBaseClass != null)
_SettingsBaseClass.Reload();
// _PropertyValues = new SettingsPropertyValueCollection();
// GetPropertyValuesCore(); // refresh the collection
} catch {
// it's possible that the (new) user doesn't have the same props
// if (_PropertyValues.Count < _Properties.Count)
// SetRemainingValuesToDefault();
}
}
}
private void SetRemainingValuesToDefault()
{
foreach (SettingsProperty prop in _Properties) {
SettingsPropertyValue value = _PropertyValues[prop.Name];
if (value == null) {
value = new SettingsPropertyValue(prop);
value.SerializedValue = prop.DefaultValue;
value.Deserialized = false;
object o = value.PropertyValue;
value.PropertyValue = o;
_PropertyValues.Add(value);
}
}
}
private string GetConnectionString()
{
if (_ConnectionString == null)
_ConnectionString = SqlHelper.GetDefaultConnectionString();
return _ConnectionString;
}
}
}