public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection props)
{
var values = new SettingsPropertyValueCollection();
foreach (SettingsProperty setting in props)
{
var value = new SettingsPropertyValue(setting);
value.IsDirty = false;
value.SerializedValue = GetValue(setting);
values.Add(value);
}
return values;
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection props)
{
// Create new collection of values
SettingsPropertyValueCollection values = new SettingsPropertyValueCollection();
string version = GetCurrentVersionNumber();
// Iterate through the settings to be retrieved
foreach (SettingsProperty prop in props)
{
SettingsPropertyValue value = GetPropertyValue(prop, version);
Debug.Assert(value != null);
values.Add(value);
}
return values;
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection props)
{
//Create new collection of values
SettingsPropertyValueCollection values = new SettingsPropertyValueCollection();
//Iterate through the settings to be retrieved
foreach (SettingsProperty setting in props)
{
SettingsPropertyValue value = new SettingsPropertyValue(setting);
value.IsDirty = false;
value.SerializedValue = GetValue(setting);
values.Add(value);
}
return values;
}
private void Upgrade(SettingsContext context, SettingsPropertyCollection properties, string user)
{
Type settingsClass = (Type)context["SettingsClassType"];
string settingsKey = (string)context["SettingsKey"];
bool isUserUpgrade = !String.IsNullOrEmpty(user);
SettingsGroupDescriptor group = new SettingsGroupDescriptor(settingsClass);
Dictionary <string, string> previousValues = GetPreviousSettingsValues(group, user, settingsKey);
bool oldValuesExist = previousValues != null && previousValues.Count > 0;
if (!oldValuesExist)
{
return; //nothing to migrate.
}
var upgradedValues = new SettingsPropertyValueCollection();
foreach (SettingsProperty property in properties)
{
if (isUserUpgrade && !IsUserScoped(property))
{
continue;
}
string oldValue;
if (!previousValues.TryGetValue(property.Name, out oldValue))
{
continue;
}
//Unconditionally save every old value; let the store sort out what to do.
upgradedValues.Add(new SettingsPropertyValue(property)
{
SerializedValue = oldValue, IsDirty = true
});
}
if (upgradedValues.Count > 0)
{
SetPropertyValues(context, upgradedValues, user);
}
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context,
SettingsPropertyCollection collection)
{
var settingsPropertyValueCollection = new SettingsPropertyValueCollection();
if (context == null || collection == null || collection.Count < 1)
{
return(settingsPropertyValueCollection);
}
var username = (string)context["_userName"];
if (string.IsNullOrWhiteSpace(username))
{
return(settingsPropertyValueCollection);
}
IMongoQuery query = Query.And(Query.EQ("ApplicationName", ApplicationName), Query.EQ("Username", username));
var bsonDocument = _mongoCollection.FindOneAs <BsonDocument>(query);
foreach (SettingsProperty settingsProperty in collection)
{
var settingsPropertyValue = new SettingsPropertyValue(settingsProperty);
settingsPropertyValueCollection.Add(settingsPropertyValue);
object value = BsonTypeMapper.MapToDotNetValue(bsonDocument[settingsPropertyValue.Name]);
if (value != null)
{
settingsPropertyValue.PropertyValue = value;
settingsPropertyValue.IsDirty = false;
settingsPropertyValue.Deserialized = true;
}
}
UpdateBuilder update = Update.Set("LastActivityDate", DateTime.Now);
_mongoCollection.Update(query, update);
return(settingsPropertyValueCollection);
}
/// <summary>
/// </summary>
/// <param name="context"></param>
/// <param name="collection"></param>
/// <returns></returns>
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context,
SettingsPropertyCollection collection)
{
// Create a collection of values to return
var retValues = new SettingsPropertyValueCollection();
// Create a temporary SettingsPropertyValue to reuse
// Loop through the list of settings that the application has requested and add them to
// our collection of return values.
foreach (var value in from SettingsProperty property in collection
select new SettingsPropertyValue(property)
{
IsDirty = false,
SerializedValue = GetSetting(property)
})
{
retValues.Add(value);
}
return(retValues);
}
{ } // private constructor
/// <summary>
/// The sole public constructor accepts the parameters required to fully
/// initialize the object.
/// </summary>
/// <param name="psettingsPropertyValueCollection">
/// Pass a reference to a System.Configuration.SettingsPropertyCollection
/// collection from which to obtain default values.
/// </param>
/// <param name="pstrInternalName">
/// The InternalName is a string that is used to identify the parameter.
/// The OperatingParametersCollection enforces unique values.
/// </param>
/// <param name="pstrDisplayName">
/// Display name is technically optional, since it defaults to the
/// internal name if this parameter is a null reference or the empty
/// string.
///
/// If the parameter contains substring DISPLAY_NAME_SUBSTITUTION_TOKEN,
/// treat it as the format string from which to construct the name of a
/// string resource in the calling assembly that is the actual display
/// name. The format string is constructed by calling string.Format to
/// substitute the value of the InternalName property for substring
/// DISPLAY_NAME_SUBSTITUTION_TOKEN, which is a valid format item token.
///
/// If the calling assembly contains no like named string, fall back to
/// InternalName, the default value.
/// </param>
/// <param name="penmParameterType">
/// The parameter type must be a valid member of the enumeration mapped
/// to the T generic type placeholder.
/// </param>
/// <param name="penmDefaultParameterSource">
/// The parameter type must be a valid member of the enumeration mapped
/// to the U generic type placeholder.
/// </param>
public OperatingParameterBase (
SettingsPropertyCollection psettingsPropertyValueCollection ,
string pstrInternalName ,
string pstrDisplayName ,
T penmParameterType ,
U penmDefaultParameterSource )
{
if ( string.IsNullOrEmpty ( pstrInternalName ) )
throw new ArgumentNullException ( nameof ( pstrInternalName ) );
_strInternalName = pstrInternalName;
_strDisplayName = string.IsNullOrEmpty ( pstrDisplayName )
? pstrInternalName
: pstrDisplayName;
lock ( s_syncRoot )
{ // Make it thread-safe.
if ( s_settingsForEntryAssembly == null )
{ // Set it once only.
if ( psettingsPropertyValueCollection != null )
{ // Do nothing if the input parameter is null.
s_settingsForEntryAssembly = AppSettingsForEntryAssembly.GetTheSingleInstance ( psettingsPropertyValueCollection );
} // TRUE (anticipated outcome) block, if ( psettingsPropertyValueCollection != null )
else
{
throw new ArgumentNullException ( );
} // FALSE (unanticipated outcome) block, if ( psettingsPropertyValueCollection != null )
} // if ( s_settingsPropertyValueCollection == null )
ParseDisplayName ( );
_enmParameterType = penmParameterType;
if ( CheckForDefaultValueInAppSettings ( _strInternalName , ref _strValue ) )
{ // Store the default value, flip the associated switch, identify the source, and flag the parameter as initialized.
_fHasDefaultValueInAppSettings = true;
_enmParameterSource = penmDefaultParameterSource;
_enmState = ParameterState.Initialized;
} // TRUE (The application cofiguration defines a default value.) block, if ( CheckForDefaultValueInAppSettings ( _stInternalName , ref _strValue ) )
} // lock ( s_syncRoot )
} // Public OperatingParameterBase constructor
public void GivenConfirmedUsersWhenGetPropertyValuesWithValidColumnsThenPropertyReturnedSuccessfully(
string providerName, string membershipProviderName)
{
// arrange
var testClass = this.WithProvider(providerName);
var memProvider = this.WithMembershipProvider(membershipProviderName);
var user = memProvider.WithConfirmedUser().Value;
var context = new SettingsContext();
context["UserName"] = user.UserName;
var properties = new SettingsPropertyCollection();
if (memProvider.AsBetter().HasEmailColumnDefined)
{
properties.Add(
new SettingsProperty(memProvider.AsBetter().UserEmailColumn)
{
PropertyType = typeof(string)
});
}
properties.Add(new SettingsProperty(memProvider.AsBetter().UserIdColumn)
{
PropertyType = typeof(int)
});
// act
var profile = testClass.GetPropertyValues(context, properties);
// assert
Assert.That(profile, Is.Not.Null);
Assert.That(profile[memProvider.AsBetter().UserIdColumn], Is.Not.Null);
Assert.That(profile[memProvider.AsBetter().UserIdColumn].PropertyValue, Is.GreaterThan(0));
Assert.That(profile[memProvider.AsBetter().UserIdColumn].IsDirty, Is.False);
if (memProvider.AsBetter().HasEmailColumnDefined)
{
Assert.That(profile[memProvider.AsBetter().UserEmailColumn].PropertyValue, Is.EqualTo(user.Email));
Assert.That(profile[memProvider.AsBetter().UserEmailColumn].IsDirty, Is.False);
}
}
/// <summary>
/// Adds default properties to the settings storage of <paramref name="settingsStorageType"/> type.
/// Properties are taken from the type definition. Only those are taken which are decorated with
/// <see cref="DefaultSettingValueAttribute"/> attribute (i.e. have default values)
/// </summary>
/// <param name="settingsStorageType">Type of the settings storage to take properties from</param>
/// <param name="propertyCollection">Collection to add instances of <see cref="SettingsProperty"/> to</param>
/// <param name="propertyValueCollection">Collection to add corresponding instances of <see cref="SettingsPropertyValue"/> to</param>
public static void AddDefaultProperties(
Type settingsStorageType,
SettingsPropertyCollection propertyCollection,
SettingsPropertyValueCollection propertyValueCollection)
{
IEnumerable <PropertyInfo> settingProperties = GetPropertiesWithAttribute(settingsStorageType, typeof(DefaultSettingValueAttribute));
foreach (PropertyInfo settingProperty in settingProperties)
{
DefaultSettingValueAttribute defaultValueAttribute = settingProperty.GetCustomAttributes(typeof(DefaultSettingValueAttribute), false)[0]
as DefaultSettingValueAttribute;
if (defaultValueAttribute != null)
{
SettingsProperty setting = BuildSettingsProperty(
settingProperty.Name, defaultValueAttribute.Value, settingProperty.PropertyType, settingProperty.GetCustomAttributes(true));
SettingsPropertyValue settingValue = BuildSettingsPropertyValue(setting);
propertyCollection.Add(setting);
propertyValueCollection.Add(settingValue);
}
}
}
public void Upgrade(SettingsContext context, SettingsPropertyCollection properties)
{
Version previousVersion = GetPreviousVersionNumber();
if (previousVersion != null)
{
Reset(context);
XmlDocument previousSettingsDoc = GetVersionedSettingsDocument(previousVersion);
if (previousSettingsDoc != null)
{
foreach (SettingsProperty property in properties)
{
SettingsPropertyValue oldValue = GetPropertyValue(previousSettingsDoc, property);
if (oldValue.PropertyValue != null)
{
SetPropertyValue(CurrentSettingsDocument, oldValue);
}
}
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Reads <paramref name="values"/> properties from the config file in
/// <paramref name="configMap"/>. Which config file to read is specified in
/// <paramref name="userLevel"/>.
/// </summary>
/// ------------------------------------------------------------------------------------
private static bool ReadProperties(SettingsContext context,
SettingsPropertyCollection properties, ExeConfigurationFileMap configMap,
ConfigurationUserLevel userLevel, SettingsPropertyValueCollection values)
{
var isReadingAppConfig = (userLevel == ConfigurationUserLevel.None);
var isReadingRoamingConfig = (userLevel == ConfigurationUserLevel.PerUserRoaming);
var config = ConfigurationManager.OpenMappedExeConfiguration(configMap, userLevel);
var groupName = (string)context["GroupName"];
var configSettings = GetSection(config, groupName,
isReadingAppConfig ? "applicationSettings" : "userSettings");
// Create new collection of values
foreach (SettingsProperty setting in properties)
{
var value = values[setting.Name];
if (value == null)
{
values.Add(new SettingsPropertyValue(setting));
value = values[setting.Name];
//value.IsDirty = true;
//value.SerializedValue = setting.DefaultValue;
}
if (IsUserScoped(setting) && isReadingRoamingConfig && !IsRoaming(setting) ||
!isReadingAppConfig && IsApplicationScoped(setting))
{
continue;
}
var elem = configSettings.Settings.Get(setting.Name);
if (elem != null)
{
SetProperty(value, elem);
}
}
return(config.HasFile);
}
public void ExceptionalGetPropertyValues()
{
SettingsPropertyCollection props = new SettingsPropertyCollection();
SettingsProviderCollection provs = new SettingsProviderCollection();
MyProvider3 p = new MyProvider3();
MySettings s = new MySettings();
props.Add(new SettingsProperty("Foo", typeof(string), p, false, 10, SettingsSerializeAs.String, null, true, true));
provs.Add(p);
s.Initialize(new SettingsContext(), props, provs);
Assert.AreEqual(0, s.Context.Count, "#0");
try {
Assert.AreEqual(100, s.Foo, "#1");
Assert.Fail("#2");
#if !TARGET_JVM
} catch (Win32Exception) {
#else
} catch (CustomerException) {
#endif
}
}
/// <summary>
/// Returns the collection of settings property values for the specified application instance and settings property group.
/// </summary>
/// <param name="context">
/// A <see cref="T:System.Configuration.SettingsContext"/> describing the current application use.
/// </param>
/// <param name="collection">
/// A <see cref="T:System.Configuration.SettingsPropertyCollection"/> containing the settings property group whose values are to be retrieved.
/// </param>
/// <returns>
/// A <see cref="T:System.Configuration.SettingsPropertyValueCollection"/> containing the values for the specified settings property group.
/// </returns>
/// <remarks>
/// </remarks>
public override SettingsPropertyValueCollection GetPropertyValues(
SettingsContext context, SettingsPropertyCollection collection)
{
var svc = new SettingsPropertyValueCollection();
if (collection == null || collection.Count < 1 || context == null)
{
return(svc);
}
var username = (string)context["UserName"];
var userIsAuthenticated = (bool)context["IsAuthenticated"];
if (String.IsNullOrEmpty(username))
{
return(svc);
}
SqlConnection conn = null;
try
{
conn = new SqlConnection(this._sqlConnectionString);
conn.Open();
this.GetProfileDataFromSproc(collection, svc, username, conn, userIsAuthenticated);
}
finally
{
if (conn != null)
{
conn.Close();
}
}
return(svc);
}
public void SerializesAndDeserializes()
{
// Arrange
var provider = new ServiceSettingsProvider();
provider.GetSettingsWriter = () => sw;
var context = new SettingsContext();
var values = new SettingsPropertyValueCollection();
var property = SettingsUtil.CreateProperty <EncryptedSecret>("myProp");
property.SerializeAs = SettingsSerializeAs.Xml;
var value = new SettingsPropertyValue(property);
var encryptedSecret = new EncryptedSecret("mySecret", 1000);
value.PropertyValue = encryptedSecret;
values.Add(value);
// Act
provider.SetPropertyValues(context, values);
// Arrange
provider.GetSettingsReader = () => new StringReader(sw.ToString());
var properties = new SettingsPropertyCollection();
properties.Add(property);
// Act
var values2 = provider.GetPropertyValues(context, properties);
var myProp = values2["myProp"].PropertyValue;
// Assert
Assert.IsAssignableFrom <EncryptedSecret>(myProp);
var encryptedSecret2 = (EncryptedSecret)myProp;
Assert.Equal("mySecret", encryptedSecret2.Decrypt());
}
// Will be called when MySettingsClass.Upgrade() is called
// This method's job is to update the location where the settings are stored
// with the previous version's values. GetPropertyValues, overriden from the
// SettingsProvider base, will be called to retrieve the new values from the
// storage location
public void Upgrade(SettingsContext context, SettingsPropertyCollection properties)
{
// If there's no previous version, do nothing (just like the LFSP)
string previousVersion = GetPreviousVersionNumber();
if (string.IsNullOrEmpty(previousVersion))
{
return;
}
// Delete the current setting values
Reset(context);
// Copy the old settings to the new version
string currentVersion = GetCurrentVersionNumber();
using (
RegistryKey keyPrevious =
Registry.CurrentUser.OpenSubKey(GetSubKeyPath(previousVersion), false))
{
using (
RegistryKey keyCurrent =
Registry.CurrentUser.CreateSubKey(GetSubKeyPath(currentVersion),
RegistryKeyPermissionCheck.
ReadWriteSubTree))
{
foreach (string valueName in keyPrevious.GetValueNames())
{
object serializedValue = keyPrevious.GetValue(valueName);
if (serializedValue != null)
{
keyCurrent.SetValue(valueName, serializedValue);
}
}
}
}
}
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);
}
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context,
SettingsPropertyCollection collection)
{
string username = (string)context["UserName"];
bool isAuthenticated = (bool)context["IsAuthenticated"];
SettingsPropertyValueCollection settingsPropertyValueCollection = new SettingsPropertyValueCollection();
foreach (SettingsProperty settingsProperty in collection)
{
SettingsPropertyValue settingsPropertyValue = new SettingsPropertyValue(settingsProperty)
{
PropertyValue = settingsProperty.DefaultValue
};
settingsPropertyValueCollection.Add(settingsPropertyValue);
}
SqlDatabase sqlDatabase = new SqlDatabase(_connectionString);
DbCommand dbCommand = sqlDatabase.GetStoredProcCommand("adm.NlayerSP_ObtenerPerfilUsuario");
sqlDatabase.AddInParameter(dbCommand, "Aplicacion", DbType.String, _applicationName);
sqlDatabase.AddInParameter(dbCommand, "Login", DbType.String, username);
sqlDatabase.AddInParameter(dbCommand, "SoloActividad", DbType.Boolean, true);
sqlDatabase.AddInParameter(dbCommand, "EstaAutenticado", DbType.Boolean, isAuthenticated);
using (IDataReader dataReader = sqlDatabase.ExecuteReader(dbCommand))
{
while (dataReader.Read())
{
SettingsPropertyValue settingsPropertyValue =
settingsPropertyValueCollection[dataReader.GetString(0)];
settingsPropertyValue.PropertyValue = dataReader.GetString(1);
}
}
return(settingsPropertyValueCollection);
}
public void Upgrade(SettingsContext context, SettingsPropertyCollection properties)
{
foreach (SettingsProperty property in properties)
{
if (!SettingsPropertyExtensions.IsUserScoped(property))
{
continue;
}
SettingsPropertyValue previousValue = SimpleSettingsStore.Instance.PreviousUserValues[property.Name];
if (previousValue == null)
{
continue;
}
SettingsPropertyValue currentValue = SimpleSettingsStore.Instance.CurrentUserValues[property.Name];
if (currentValue == null)
{
continue;
}
currentValue.PropertyValue = previousValue.PropertyValue;
}
}
public override SettingsPropertyValueCollection GetPropertyValues(
SettingsContext context,
SettingsPropertyCollection collection
)
{
var result = new SettingsPropertyValueCollection();
foreach (SettingsProperty property in collection)
{
var value = new SettingsPropertyValue(property);
if (KnownProperties.Contains(property.Name))
{
value.PropertyValue = Settings
.Current
.GetType()
.GetField(value.Property.Name)
.GetValue(Settings.Current);
}
result.Add(value);
}
return(result);
}
/// <summary>
/// Gets property values
/// </summary>
/// <param name="context"></param>
/// <param name="collection"></param>
/// <returns></returns>
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context,
SettingsPropertyCollection collection)
{
SettingsPropertyValueCollection svc = new SettingsPropertyValueCollection();
if (collection == null || collection.Count < 1 || context == null)
{
return(svc);
}
string username = (string)context["UserName"];
if (String.IsNullOrEmpty(username))
{
return(svc);
}
NpgsqlConnection conn = null;
try
{
conn = new NpgsqlConnection(_NpgsqlConnectionString);
conn.Open();
GetProfileDataFromTable(collection, svc, username, conn);
}
finally
{
if (conn != null)
{
conn.Close();
}
}
return(svc);
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context,
SettingsPropertyCollection collection)
{
var results = new SettingsPropertyValueCollection();
if (collection.Count < 1)
{
return(results);
}
var username = (string)context["UserName"];
foreach (SettingsProperty prop in collection)
{
if (prop.SerializeAs == SettingsSerializeAs.ProviderSpecific)
{
if (prop.PropertyType.IsPrimitive || prop.PropertyType == typeof(string))
{
prop.SerializeAs = SettingsSerializeAs.String;
}
else
{
prop.SerializeAs = SettingsSerializeAs.Xml;
}
}
results.Add(new SettingsPropertyValue(prop));
}
if (!string.IsNullOrWhiteSpace(username))
{
GetPropertyValuesFromDatabase(username, results);
}
return(results);
}
public TransportSettingsPropertyValueCollection GetPropertyValues(string applicationName, TransportSettingsContext context, TransportSettingsPropertyCollection collection)
{
_Provider.ApplicationName = _ApplicationName;
var settingscontext = new SettingsContext {
{ "UserName", context.Username }, { "IsAuthenticated", context.IsAuthenticated }
};
var settingspropertycollection = new SettingsPropertyCollection();
foreach (TransportSettingsProperty settingsproperty in collection)
{
settingspropertycollection.Add(ConvertSettingsProperty(settingsproperty));
}
var returncollection = new TransportSettingsPropertyValueCollection();
foreach (SettingsPropertyValue settingspropertyvalue in _Provider.GetPropertyValues(settingscontext, settingspropertycollection))
{
returncollection.Add(ConvertSettingsPropertyValue(settingspropertyvalue));
}
return(returncollection);
}
GetPropertyValues(SettingsContext context,
SettingsPropertyCollection ppc)
{
string username = (string)context["UserName"];
bool isAuthenticated = (bool)context["IsAuthenticated"];
// The serializeAs attribute is ignored in this provider implementation.
SettingsPropertyValueCollection svc =
new SettingsPropertyValueCollection();
foreach (SettingsProperty prop in ppc)
{
SettingsPropertyValue pv = new SettingsPropertyValue(prop);
switch (prop.Name)
{
case "StockSymbols":
pv.PropertyValue = GetStockSymbols(username, isAuthenticated);
break;
case "ZipCode":
pv.PropertyValue = GetZipCode(username, isAuthenticated);
break;
default:
throw new ProviderException("Unsupported property.");
}
svc.Add(pv);
}
UpdateActivityDates(username, isAuthenticated, true);
return(svc);
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection)
{
IProfile dal = Snitz.Membership.Helpers.Factory<IProfile>.Create("Profile");
dal.TableName = _table;
SettingsPropertyValueCollection vc = dal.GetPropertyValues(context, collection);
return vc;
}
public Profile()
{
state = ProfileState.Anonymous;
defualtProfileSettings = ProfileBase.Properties;
}
// Will be called when MySettingsClass.Upgrade() is called
// This method's job is to update the location where the settings are stored
// with the previous version's values. GetPropertyValues, overriden from the
// SettingsProvider base, will be called to retrieve the new values from the
// storage location
public void Upgrade(SettingsContext context, SettingsPropertyCollection properties)
{
// If there's no previous version, do nothing (just like the LFSP)
string previousVersion = GetPreviousVersionNumber();
if (string.IsNullOrEmpty(previousVersion)) { return; }
// Delete the current setting values
Reset(context);
// Copy the old settings to the new version
string currentVersion = GetCurrentVersionNumber();
using (RegistryKey keyPrevious = Registry.LocalMachine.OpenSubKey(GetSubKeyPath(previousVersion), false))
using (RegistryKey keyCurrent = Registry.LocalMachine.CreateSubKey(GetSubKeyPath(currentVersion), RegistryKeyPermissionCheck.ReadWriteSubTree))
{
foreach (string valueName in keyPrevious.GetValueNames())
{
object serializedValue = keyPrevious.GetValue(valueName);
if (serializedValue != null) { keyCurrent.SetValue(valueName, serializedValue); }
}
}
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection)
{
string username = (string)context["UserName"];
bool isAuthenticated = (bool)context["IsAuthenticated"];
Dictionary<string, object> values = _profileValues.ContainsKey(username) ? _profileValues[username] : null;
SettingsPropertyValueCollection spvc = new SettingsPropertyValueCollection();
foreach (SettingsProperty prop in collection)
{
SettingsPropertyValue spv = new SettingsPropertyValue(prop);
if (values != null && values.ContainsKey(prop.Name))
{
spv.PropertyValue = values[prop.Name];
}
else
{
spv.PropertyValue = prop.DefaultValue;
}
spvc.Add(spv);
}
return spvc;
}
/// <summary>
/// Retrieves profile property information and values from a SQL Server profile database.
/// </summary>
/// <param name="sc">The <see cref="T:System.Configuration.SettingsContext"></see> that contains user profile information.</param>
/// <param name="properties">A <see cref="T:System.Configuration.SettingsPropertyCollection"></see> containing profile information for the properties to be retrieved.</param>
/// <returns>
/// A <see cref="T:System.Configuration.SettingsPropertyValueCollection"></see> containing profile property information and values.
/// </returns>
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext sc, SettingsPropertyCollection properties)
{
SettingsPropertyValueCollection props = base.GetPropertyValues(sc, properties);
// Retrieve the data from the Database
string userName = (string)sc["UserName"];
if (!String.IsNullOrEmpty(userName))
{
MembershipUser user = Membership.GetUser(userName);
if (user != null)
{
PopulateAccountFromDatabase(new Guid(user.ProviderUserKey.ToString()), props);
}
}
if (props["PageSettings"] != null)
{
props["PageSettings"].Property.SerializeAs = SettingsSerializeAs.Binary;
}
return(props);
}
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext sc, SettingsPropertyCollection properties)
{
SettingsPropertyValueCollection svc = new SettingsPropertyValueCollection();
if (properties.Count < 1)
{
return(svc);
}
string username = (string)sc["UserName"];
foreach (SettingsProperty prop in properties)
{
if (prop.SerializeAs == SettingsSerializeAs.ProviderSpecific)
{
if (prop.PropertyType.IsPrimitive || prop.PropertyType == typeof(string))
{
prop.SerializeAs = SettingsSerializeAs.String;
}
else
{
prop.SerializeAs = SettingsSerializeAs.Xml;
}
}
svc.Add(new SettingsPropertyValue(prop));
}
if (!String.IsNullOrEmpty(username))
{
GetPropertyValuesFromDatabase(username, svc);
}
return(svc);
}
public SettingsPropertyValueCollection GetPropertyValues(string currentUser, SettingsContext context, SettingsPropertyCollection collection, out int errorNumber, out string errorDescription)
{
errorNumber = 0;
errorDescription = string.Empty;
SettingsPropertyValueCollection settings = new SettingsPropertyValueCollection();
if (collection == null || collection.Count == 0)
{
return(settings);
}
foreach (SettingsProperty property in collection)
{
if (property.SerializeAs == SettingsSerializeAs.ProviderSpecific)
{
if (property.PropertyType.IsPrimitive || property.PropertyType == typeof(System.String))
{
property.SerializeAs = SettingsSerializeAs.String;
}
else
{
property.SerializeAs = SettingsSerializeAs.Xml;
}
}
settings.Add(new SettingsPropertyValue(property));
}
// Get the user name or anonymous user ID
string username = (string)context["UserName"];
//' NOTE: Consider validating the user name here to prevent
//' malicious user names such as "../Foo" from targeting
//' directories other than ~/App_Data/Profile_Data
//' Load the profile
if (!string.IsNullOrEmpty(username))
{
string[] names;
string values;
byte[] buf;
string databaseNames;
string databaseValues;
DataTable table = base.ExecuteFill(CommandType.StoredProcedure, "Framework_ProfileGetProperties",
true, currentUser,
base.Parameters.Create("@ReturnValue", DbType.Int32, ParameterDirection.ReturnValue, null),
base.Parameters.Create("@ApplicationName", DbType.String, _applicationName),
base.Parameters.Create("@UserName", DbType.String, username));
errorNumber = base.ExecutionStatus.ErrorNumber;
errorDescription = base.ExecutionStatus.ErrorDescription;
if (errorNumber > 0 || !string.IsNullOrEmpty(errorDescription))
{
return(settings);
}
if (table.Rows.Count == 0)
{
return(settings);
}
databaseNames = Convert.ToString(table.Rows[0]["PropertyNames"]);
databaseValues = Convert.ToString(table.Rows[0]["PropertyValuesString"]);
buf = (byte[])table.Rows[0]["PropertyValuesBinary"];
names = databaseNames.Split(':');
values = databaseValues;
// Decode names, values, and buf and initialize the
// SettingsPropertyValueCollection returned to the caller
Convertion.Profile.DecodeProfileData(names, values, buf, settings);
}
return(settings);
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext sc, SettingsPropertyCollection properties)
{
// create the collection to return
SettingsPropertyValueCollection spvc = new SettingsPropertyValueCollection();
#region Check The Function Parameters Are Valid
// check we have the user profile information.
if (sc == null)
{
return spvc;
}
// check we do have the profile information for the properties to be retrieved.
// check we do have properties in the profile
if (properties == null || properties.Count < 1)
{
return spvc;
}
// get the username
// get if the user is authenticated
// if the username is null or empty, return empty property value collection
Boolean isAuthenticated = (Boolean)sc["IsAuthenticated"];
String username = (String)sc["UserName"];
if (String.IsNullOrEmpty(username))
{
return spvc;
}
#endregion
#region Fill the collection to return with the profile properties initialized to their default values
foreach (SettingsProperty sp in properties)
{
// If the serialization is up to us to decide, try and see if it can be serialised as a string
// otherwise serialise as XML
if (sp.SerializeAs == SettingsSerializeAs.ProviderSpecific)
{
// If it is a primitive type or a string, then just store it as a string
if (sp.PropertyType.IsPrimitive || (sp.PropertyType == typeof(string)))
{
sp.SerializeAs = SettingsSerializeAs.String;
}
else // Else serialize it as XML
{
sp.SerializeAs = SettingsSerializeAs.Xml;
}
}
// create a property value based on the profile property settings, including default value
// Add the property value to the collection to return
spvc.Add(new SettingsPropertyValue(sp));
}
#endregion
#region Retrieve the stored property values from the database
try
{
GetNonDefaultPropertyValuesForUser(username, spvc);
}
catch (Exception e)
{
// if anything went wrong, throw an exception
throw new ProviderException(String.Format(
"Error getting profile property values from database.\nUsername: '******'\nIs Authenticated: {1}",
username, isAuthenticated.ToString()), e);
}
#endregion
return spvc;
}
public void Initialize(SettingsContext context, SettingsPropertyCollection properties, SettingsProviderCollection providers) {}
public virtual void Upgrade(SettingsContext context, SettingsPropertyCollection properties) {}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection)
{
// коллекция, которая возвращает значения свойств профиля
SettingsPropertyValueCollection result = new SettingsPropertyValueCollection();
if (collection == null || collection.Count < 1 || context == null)
{
return(result);
}
// получаем из контекста имя пользователя - логин в системе
string username = (string)context["UserName"];
if (String.IsNullOrEmpty(username))
{
return(result);
}
UserContext db = new UserContext();
// получаем id пользователя из таблицы Users по логину
int userId = db.Users.Where(u => u.Email.Equals(username)).FirstOrDefault().Id;
// по этому id извлекаем профиль из таблицы профилей
Profile profile = db.Profiles.Where(u => u.UserId == userId).FirstOrDefault();
if (profile != null)
{
foreach (SettingsProperty prop in collection)
{
SettingsPropertyValue svp = new SettingsPropertyValue(prop);
svp.PropertyValue = profile.GetType().GetProperty(prop.Name).GetValue(profile, null);
result.Add(svp);
}
}
else
{
foreach (SettingsProperty prop in collection)
{
SettingsPropertyValue svp = new SettingsPropertyValue(prop);
svp.PropertyValue = null;
result.Add(svp);
}
}
return(result);
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection)
{
SettingsPropertyValueCollection values = new SettingsPropertyValueCollection();
foreach (SettingsProperty property in collection)
{
SettingsPropertyValue value2 = new SettingsPropertyValue(property)
{
SerializedValue = this.ORQDXIXSVMHEUQKWSBBRZO(property)
};
values.Add(value2);
}
return(values);
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection)
{
lock (_Lock)
{
SettingsPropertyValueCollection valueCollection = new SettingsPropertyValueCollection();
XmlDocument doc = new XmlDocument();
if (File.Exists(Filename))
{
try
{
doc.LoadXml(File.ReadAllText(Filename));
}
catch (XmlException)
{
doc = new XmlDocument();
}
catch (IOException)
{
doc = new XmlDocument();
}
}
else
{
// Create the directory and the file.
try
{
Directory.CreateDirectory(Path.GetDirectoryName(Filename));
File.Create(Filename).Close();
}
catch (IOException)
{
// Couldn't create the file. Ignore for now.
}
}
XmlNode root = SetupDocument(doc);
XmlNode appRoot = root.SelectSingleNode("ApplicationSettings");
XmlNode userRoot = root.SelectSingleNode("UserSettings");
// Get the settings
foreach (SettingsProperty setting in collection)
{
XmlNode node = IsUserScoped(setting) ? userRoot.SelectSingleNode(setting.Name) : appRoot.SelectSingleNode(setting.Name);
// Add the property to the list.
SettingsPropertyValue value = new SettingsPropertyValue(setting);
value.IsDirty = false;
value.SerializedValue = node != null ? node.InnerText : setting.DefaultValue;
valueCollection.Add(value);
}
return(valueCollection);
}
}
// Retrieve settings from the configuration file
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext sContext, SettingsPropertyCollection settingsColl)
{
// Create a collection of values to return
SettingsPropertyValueCollection retValues = new SettingsPropertyValueCollection();
// Create a temporary SettingsPropertyValue to reuse
SettingsPropertyValue setVal;
// Loop through the list of settings that the application has requested and add them
// to our collection of return values.
foreach (SettingsProperty sProp in settingsColl)
{
setVal = new SettingsPropertyValue(sProp);
setVal.IsDirty = false;
setVal.SerializedValue = GetSetting(sProp);
retValues.Add(setVal);
}
return retValues;
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext sc, SettingsPropertyCollection properties)
{
SettingsPropertyValueCollection settings = new SettingsPropertyValueCollection();
if (properties.Count == 0)
{
return(settings);
}
foreach (SettingsProperty property in properties)
{
if (property.SerializeAs == SettingsSerializeAs.ProviderSpecific)
{
if (property.PropertyType.IsPrimitive || property.PropertyType == typeof(String))
{
property.SerializeAs = SettingsSerializeAs.String;
}
else
{
property.SerializeAs = SettingsSerializeAs.Xml;
}
}
settings.Add(new SettingsPropertyValue(property));
}
string username = (string)sc ["UserName"];
DbDataReader reader;
using (DbConnection connection = CreateConnection()) {
DerbyProfileHelper.Profile_GetProperties(connection, ApplicationName, username, DateTime.UtcNow, out reader);
if (reader != null)
{
using (reader) {
if (reader.Read())
{
string allnames = reader.GetString(0);
string allvalues = reader.GetString(1);
int binaryLen = (int)reader.GetBytes(2, 0, null, 0, 0);
byte [] binaryvalues = new byte [binaryLen];
reader.GetBytes(2, 0, binaryvalues, 0, binaryLen);
DecodeProfileData(allnames, allvalues, binaryvalues, settings);
}
}
}
}
return(settings);
}
public virtual SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection properties) {}
public void Upgrade(SettingsContext context, SettingsPropertyCollection properties)
{
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection)
{
Monitor.Enter(GetValuesLock);
SettingsPropertyValueCollection values = new SettingsPropertyValueCollection();
//Iterate through the settings to be retrieved
foreach(SettingsProperty setting in collection)
{
SettingsPropertyValue value = new SettingsPropertyValue(setting);
value.IsDirty = false;
value.SerializedValue = GetValue(setting);
values.Add(value);
}
Monitor.Exit(GetValuesLock);
return values;
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection props)
{
//Create new collection of values
var values = new SettingsPropertyValueCollection();
//Iterate through the settings to be retrieved
foreach (SettingsProperty setting in props)
{
var value = new SettingsPropertyValue(setting)
{
IsDirty = false,
SerializedValue = GetValue(setting)
};
values.Add(value);
}
return(values);
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection properties)
{
SettingsPropertyValueCollection settings = new SettingsPropertyValueCollection();
// Do nothing if there are no properties to retrieve
if (properties.Count == 0)
return settings;
// For properties lacking an explicit SerializeAs setting, set
// SerializeAs to String for strings and primitives, and XML
// for everything else
foreach (SettingsProperty property in properties)
{
if (property.SerializeAs == SettingsSerializeAs.ProviderSpecific)
{
if (property.PropertyType.IsPrimitive || property.PropertyType == typeof(String))
{
property.SerializeAs = SettingsSerializeAs.String;
}
else
{
property.SerializeAs = SettingsSerializeAs.Xml;
}
}
settings.Add(new SettingsPropertyValue(property));
}
// Get the user name or anonymous user ID
string username = (string) context["UserName"];
// NOTE: Consider validating the user name here to prevent
// malicious user names such as "../Foo" from targeting
// directories other than Profile_Data
// Load the profile
if (!String.IsNullOrEmpty(username))
{
StreamReader reader = null;
string[] names;
string values;
byte[] buf = null;
try
{
// Open the file containing the profile data
try
{
string path = string.Format(ProfilePathFormatString, username.Replace('\\', '_'));
reader = new StreamReader(path);
}
catch (IOException)
{
// Not an error if file doesn't exist
return settings;
}
// Read names, values, and buf from the file
names = reader.ReadLine().Split(':');
values = reader.ReadLine();
if (!string.IsNullOrEmpty(values))
{
UnicodeEncoding encoding = new UnicodeEncoding();
values = encoding.GetString
(Convert.FromBase64String(values));
}
string temp = reader.ReadLine();
if (!String.IsNullOrEmpty(temp))
{
buf = Convert.FromBase64String(temp);
}
else
buf = new byte[0];
}
finally
{
if (reader != null)
reader.Close();
}
// Decode names, values, and buf and initialize the
// SettingsPropertyValueCollection returned to the caller
DecodeProfileData(names, values, buf, settings);
}
return settings;
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection)
{
SettingsPropertyValueCollection result = new SettingsPropertyValueCollection();
SettingsProperty property = new SettingsProperty("StringPropertyWithProvider", typeof(string), this, false, DefaultStringPropertyValue, SettingsSerializeAs.String, new SettingsAttributeDictionary(), false, false);
result.Add(new SettingsPropertyValue(new SettingsProperty(property)));
return(result);
}
// Methods
public abstract virtual SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection)
{
}
