private static void SetSharedPropertyValues(ApplicationSettingsBase settings, Dictionary<string, string> values) { foreach (SettingsProvider provider in settings.Providers) { ISharedApplicationSettingsProvider sharedSettingsProvider = GetSharedSettingsProvider(provider); if (sharedSettingsProvider == null) throw new NotSupportedException("Setting shared values is not supported."); var properties = GetPropertiesForProvider(settings, provider); SettingsPropertyValueCollection settingsValues = new SettingsPropertyValueCollection(); foreach (var value in values) { SettingsProperty property = properties[value.Key]; if (property == null) continue; settingsValues.Add(new SettingsPropertyValue(property) { SerializedValue = value.Value, IsDirty = true }); } sharedSettingsProvider.SetSharedPropertyValues(settings.Context, settingsValues); } SaveIfDirty(settings); settings.Reload(); }
public SettingsPropertyValueCollection LoadValues(string userName, SettingsPropertyCollection props) { var svc = new SettingsPropertyValueCollection(); // holds sourcename->data pairs var loadedData = new Dictionary<string, IDictionary>(); foreach (SettingsProperty prop in props) { EnsureDataLoaded(userName, prop.Name, loadedData); var pv = new SettingsPropertyValue(prop); object value = null; // lets try to locate property value foreach (var src in Sources) if (src.FieldsMapping.ContainsKey(prop.Name)) { value = loadedData[src.SourceName][ ResolveFieldName(prop.Name,src) ]; break; } if (value == null || value == DBNull.Value) { // leave default value } else { pv.PropertyValue = value; pv.IsDirty = false; } svc.Add(pv); } return svc; }
/// <summary> /// Must override this, this is the bit that matches up the designer properties to the dictionary values /// </summary> /// <param name="context"></param> /// <param name="collection"></param> /// <returns></returns> public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection) { //load the file if (!_loaded) { _loaded = true; LoadValuesFromFile(); } //collection that will be returned. SettingsPropertyValueCollection values = new SettingsPropertyValueCollection(); //itterate thought the properties we get from the designer, checking to see if the setting is in the dictionary foreach (SettingsProperty setting in collection) { SettingsPropertyValue value = new SettingsPropertyValue(setting); value.IsDirty = false; //need the type of the value for the strong typing var t = Type.GetType(setting.PropertyType.FullName); if (SettingsDictionary.ContainsKey(setting.Name)) { value.SerializedValue = SettingsDictionary[setting.Name].value; value.PropertyValue = Convert.ChangeType(SettingsDictionary[setting.Name].value, t); } else //use defaults in the case where there are no settings yet { value.SerializedValue = setting.DefaultValue; value.PropertyValue = Convert.ChangeType(setting.DefaultValue, t); } values.Add(value); } return values; }
public static SettingsPropertyValueCollection GetSharedPropertyValues(LocalFileSettingsProvider provider, SettingsContext context, SettingsPropertyCollection properties, string currentExeConfigFilename = null) { var settingsClass = (Type)context["SettingsClassType"]; var systemConfiguration = String.IsNullOrEmpty(currentExeConfigFilename) ? SystemConfigurationHelper.GetExeConfiguration() : SystemConfigurationHelper.GetExeConfiguration(currentExeConfigFilename); var storedValues = systemConfiguration.GetSettingsValues(settingsClass); // Create new collection of values var values = new SettingsPropertyValueCollection(); foreach (SettingsProperty setting in properties) { var value = new SettingsPropertyValue(setting) { SerializedValue = storedValues.ContainsKey(setting.Name) ? storedValues[setting.Name] : null, IsDirty = false }; // use the stored value, or set the SerializedValue to null, which tells .NET to use the default value values.Add(value); } return values; }
// SetPropertyValue is invoked when ApplicationSettingsBase.Save is called // ASB makes sure to pass each provider only the values marked for that provider, // whether on a per setting or setting class-wide basis public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection propvals) { // Iterate through the settings to be stored string version = GetCurrentVersionNumber(); foreach (SettingsPropertyValue propval in propvals) { // If property hasn't been set, no need to save it if (!propval.IsDirty || (propval.SerializedValue == null)) { continue; } // Application-scoped settings can't change // NOTE: the settings machinery may cause or allow an app-scoped setting // to become dirty, in which case, like the LFSP, we ignore it instead // of throwning an exception if (IsApplicationScoped(propval.Property)) { continue; } using (RegistryKey key = CreateRegKey(propval.Property, version)) { key.SetValue(propval.Name, propval.SerializedValue); } } }
/// ------------------------------------------------------------------------------------ /// <summary> /// Gets the property values from a config file. /// </summary> /// ------------------------------------------------------------------------------------ public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection properties) { // Set the config files var configMap = SetConfigFiles(); // Create new collection of values var values = new SettingsPropertyValueCollection(); ReadProperties(context, properties, configMap, ConfigurationUserLevel.None, values); ReadProperties(context, properties, configMap, ConfigurationUserLevel.PerUserRoamingAndLocal, values); ReadProperties(context, properties, configMap, ConfigurationUserLevel.PerUserRoaming, values); // save new user config file try { SetPropertyValues(context, values); } catch { } return values; }
/// <summary> /// Returns the collection of settings property values for the specified application instance and settings property group. /// </summary> /// <param name="context">A System.Configuration.SettingsContext describing the current application use.</param> /// <param name="collection">A System.Configuration.SettingsPropertyCollection containing the settings property group whose values are to be retrieved.</param> /// <returns>A System.Configuration.SettingsPropertyValueCollection containing the values for the specified settings property group.</returns> public override SettingsPropertyValueCollection GetPropertyValues( SettingsContext context, SettingsPropertyCollection collection) { string username = (string)context["UserName"]; bool isAuthenticated = (bool) context["IsAuthenticated"]; SettingsPropertyValueCollection svc = new SettingsPropertyValueCollection(); foreach (SettingsProperty prop in collection) { SettingsPropertyValue pv = new SettingsPropertyValue(prop); switch (pv.Property.Name) { case PROFILE_SHOPPINGCART: pv.PropertyValue = GetCartItems(username, true); break; case PROFILE_WISHLIST: pv.PropertyValue = GetCartItems(username, false); break; case PROFILE_ACCOUNT: if (isAuthenticated) pv.PropertyValue = GetAccountInfo(username); break; default: throw new ApplicationException(ERR_INVALID_PARAMETER + " name."); } svc.Add(pv); } return svc; }
public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection collection) { if (_localFileSettingProvider != null) { _localFileSettingProvider.SetPropertyValues(context, collection); } }
/// <summary> /// Updates the specified settings from this config class. /// </summary> /// <param name="settings">The settings.</param> public void Update(SettingsPropertyValueCollection settings) { foreach (PropertyInfo configProperty in this.GetType().GetProperties()) { settings[configProperty.Name].PropertyValue = configProperty.GetValue(this, null); } }
public object Clone () { SettingsPropertyValueCollection col = new SettingsPropertyValueCollection (); col.items = (Hashtable)items.Clone (); return col; }
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection) { SettingsPropertyValueCollection result = new SettingsPropertyValueCollection(); if (collection.Count < 1) return result; string userEmail = (string) context["UserName"]; //Эта строка мне пока не понятна if (string.IsNullOrEmpty(userEmail)) return result; var user = UserService.GetByEmail(userEmail); var profile = ProfileService.GetProfile(user); foreach (SettingsProperty prop in collection) { SettingsPropertyValue svp = new SettingsPropertyValue(prop) { PropertyValue = profile.GetType().GetProperty(prop.Name).GetValue(profile, null) }; result.Add(svp); } return result; }
public void SettingValuesCreatesAnAppAndUserId() { MySQLProfileProvider provider = InitProfileProvider(); SettingsContext ctx = new SettingsContext(); ctx.Add("IsAuthenticated", false); ctx.Add("UserName", "user1"); SettingsPropertyValueCollection values = new SettingsPropertyValueCollection(); SettingsProperty property1 = new SettingsProperty("color"); property1.PropertyType = typeof(string); property1.Attributes["AllowAnonymous"] = true; SettingsPropertyValue value = new SettingsPropertyValue(property1); value.PropertyValue = "blue"; values.Add(value); provider.SetPropertyValues(ctx, values); DataTable dt = FillTable("SELECT * FROM my_aspnet_applications"); Assert.AreEqual(1, dt.Rows.Count); dt = FillTable("SELECT * FROM my_aspnet_users"); Assert.AreEqual(1, dt.Rows.Count); dt = FillTable("SELECT * FROM my_aspnet_profiles"); Assert.AreEqual(1, dt.Rows.Count); values["color"].PropertyValue = "green"; provider.SetPropertyValues(ctx, values); dt = FillTable("SELECT * FROM my_aspnet_applications"); Assert.AreEqual(1, dt.Rows.Count); dt = FillTable("SELECT * FROM my_aspnet_users"); Assert.AreEqual(1, dt.Rows.Count); dt = FillTable("SELECT * FROM my_aspnet_profiles"); Assert.AreEqual(1, dt.Rows.Count); }
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection props) { XmlSettingsFile localFile = XmlSettingsFile.GetLocalSettingsFile(GetTypeFromContext(context)); XmlSettingsFile roamingFile = XmlSettingsFile.GetRoamingSettingsFile(GetTypeFromContext(context)); SettingsPropertyValueCollection values = new SettingsPropertyValueCollection(); foreach (SettingsProperty setting in props) { SettingsPropertyValue value = new SettingsPropertyValue(setting); value.IsDirty = false; if (IsRoaming(setting)) { value.SerializedValue = roamingFile.GetValue(setting); } else { value.SerializedValue = localFile.GetValue(setting); } values.Add(value); } return values; }
public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection collection) { lock (_syncLock) { // locate dirty values that should be saved var valuesToStore = new Dictionary<string, string>(); foreach (SettingsPropertyValue value in collection) { //If storing the shared values, we store everything, otherwise only store user values. if (value.IsDirty) { valuesToStore[value.Name] = (string) value.SerializedValue; } } if (valuesToStore.Count > 0) { var settingsClass = (Type)context["SettingsClassType"]; var settingsKey = (string)context["SettingsKey"]; var group = new SettingsGroupDescriptor(settingsClass); if (group.HasUserScopedSettings) throw new ConfigurationErrorsException(SR.SystemConfigurationSettingsProviderUserSetting); _store.PutSettingsValues(group, null, settingsKey, valuesToStore); // successfully saved user settings are no longer dirty foreach (var storedValue in valuesToStore) collection[storedValue.Key].IsDirty = false; } } }
/// <summary> /// Must override this, this is the bit that matches up the designer properties to the dictionary values /// </summary> /// <param name="context"></param> /// <param name="collection"></param> /// <returns></returns> public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection) { //load the file if (!_loaded) { _loaded = true; LoadValuesFromFile(); } //collection that will be returned. SettingsPropertyValueCollection values = new SettingsPropertyValueCollection(); //itterate thought the properties we get from the designer, checking to see if the setting is in the dictionary foreach (SettingsProperty setting in collection) { SettingsPropertyValue value = new SettingsPropertyValue(setting); value.IsDirty = false; if (SettingsDictionary.ContainsKey(setting.Name)) { value.SerializedValue = SettingsDictionary[setting.Name].value; } else //use defaults in the case where there are no settings yet { value.SerializedValue = setting.DefaultValue == null ? string.Empty : setting.DefaultValue.ToString(); } values.Add(value); } return values; }
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection) { // set all of the inherited default values first in case we have failure later SettingsPropertyValueCollection settings = new SettingsPropertyValueCollection(); foreach (SettingsProperty prop in collection) { SettingsPropertyValue spv = new SettingsPropertyValue(prop); spv.SerializedValue = prop.DefaultValue; settings.Add(spv); } // now read in overridden user settings try { Configuration config = null; ClientSettingsSection clientSettings = GetUserSettings(out config, true); foreach (SettingsPropertyValue spv in settings) { DeserializeFromXmlElement(spv.Property, spv, clientSettings); } } catch { // suppress } return settings; }
/// <summary> /// Returns the collection of settings property values for the specified application instance and settings property group. /// </summary> /// <returns> /// A <see cref="T:System.Configuration.SettingsPropertyValueCollection"/> containing the values for the specified settings property group. /// </returns> /// <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><filterpriority>2</filterpriority> public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection) { var username = (string) context["UserName"]; var isAuthenticated = (bool) context["IsAuthenticated"]; Profile profile = ProfileManager.Instance.GetCurrentUser(username); var svc = new SettingsPropertyValueCollection(); foreach (SettingsProperty prop in collection) { var pv = new SettingsPropertyValue(prop); switch (pv.Property.Name) { case _PROFILE_SHOPPINGCART: pv.PropertyValue = CartList.GetCart(profile.UniqueID, true); break; case _PROFILE_WISHLIST: pv.PropertyValue = CartList.GetCart(profile.UniqueID, false); break; case _PROFILE_ACCOUNT: if (isAuthenticated) pv.PropertyValue = new Address(profile); break; default: throw new ApplicationException(string.Format("{0} name.", _ERR_INVALID_PARAMETER)); } svc.Add(pv); } return svc; }
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection) { var properties = new SettingsPropertyValueCollection(); if (collection.Count < 1) return properties; var username = (string) context["UserName"]; foreach (SettingsProperty property in collection) { properties.Add(new SettingsPropertyValue(property)); } var db = new MyLifeEntities(); var profile = db.tblProfiles.Where(item => item.UserName == username).FirstOrDefault(); if (profile != null) { var names = profile.PropertyNames.Split(new[] {";#"}, StringSplitOptions.RemoveEmptyEntries); var values = profile.PropertyValues.Split(new[] {";#"}, StringSplitOptions.RemoveEmptyEntries); if (names.Length > 0 && values.Length > 0) { for (var i = 0; i < names.Length; i++) { var property = properties[names[i]]; if (property == null) continue; property.PropertyValue = Base64Serializer.Deserialize(values[i]); } } } return properties; }
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection) { SettingsPropertyValueCollection v = new SettingsPropertyValueCollection(); value = new SettingsPropertyValue(new SettingsProperty("Style")); value.PropertyValue = "null"; v.Add(value); return v; }
public override void SetPropertyValues (SettingsContext context, SettingsPropertyValueCollection values) { #if SPEW Console.WriteLine (Environment.StackTrace); #endif base.SetPropertyValues (context, values); }
private SimpleSettingsStore() { _stores = new Dictionary<Store, SettingsPropertyValueCollection>(); _stores[Store.CurrentUser] = CurrentUserValues = new SettingsPropertyValueCollection(); _stores[Store.PreviousUser] = PreviousUserValues = new SettingsPropertyValueCollection(); _stores[Store.CurrentShared] = CurrentSharedValues = new SettingsPropertyValueCollection(); _stores[Store.PreviousShared] = PreviousSharedValues = new SettingsPropertyValueCollection(); }
private static int PackProfileData(SettingsPropertyValueCollection collection, bool isAuthenticated, ref string index, ref string stringData, ref byte[] binaryData) { bool itemsToSave = false; // first we need to determine if there are any items that need saving // this is an optimization foreach (SettingsPropertyValue value in collection) { if (!value.IsDirty) continue; if (value.Property.Attributes["AllowAnonymous"].Equals(false) && !isAuthenticated) continue; itemsToSave = true; break; } if (!itemsToSave) return 0; StringBuilder indexBuilder = new StringBuilder(); StringBuilder stringDataBuilder = new StringBuilder(); MemoryStream binaryBuilder = new MemoryStream(); int count = 0; // ok, we have some values that need to be saved so we go back through foreach (SettingsPropertyValue value in collection) { // if the value has not been written to and is still using the default value // no need to save it if (value.UsingDefaultValue && !value.IsDirty) continue; // we don't save properties that require the user to be authenticated when the // current user is not authenticated. if (value.Property.Attributes["AllowAnonymous"].Equals(false) && !isAuthenticated) continue; count++; object propValue = value.SerializedValue; if ((value.Deserialized && value.PropertyValue == null) || value.SerializedValue == null) indexBuilder.AppendFormat("{0}//0/-1:", value.Name); else if (propValue is string) { indexBuilder.AppendFormat("{0}/0/{1}/{2}:", value.Name, stringDataBuilder.Length, (propValue as string).Length); stringDataBuilder.Append(propValue); } else { byte[] binaryValue = (byte[])propValue; indexBuilder.AppendFormat("{0}/1/{1}/{2}:", value.Name, binaryBuilder.Position, binaryValue.Length); binaryBuilder.Write(binaryValue, 0, binaryValue.Length); } } index = indexBuilder.ToString(); stringData = stringDataBuilder.ToString(); binaryData = binaryBuilder.ToArray(); return count; }
private Property CreateProperty(PropertyInfo property, SettingsProperty settingsProperty, SettingsPropertyValueCollection settingsPropertyValues) { var descriptor = new SettingsPropertyDescriptor(property); var settingsPropertyValue = settingsPropertyValues[settingsProperty.Name]; var defaultValue = settingsProperty.DefaultValue; var serializedValue = settingsPropertyValue == null ? null : settingsPropertyValue.SerializedValue; return new Property(descriptor, (serializedValue ?? defaultValue).ToString()); }
public static SettingsPropertyValueCollection ToSettingsPropertyValueCollection(this IEnumerable<SettingsPropertyValue> values) { var c = new SettingsPropertyValueCollection(); foreach (var value in values) { c.Add(value); } return c; }
public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection propvals) { foreach (SettingsPropertyValue value2 in propvals) { SetValue(value2); } try { SettingsXML.Save(Path.Combine(GetAppSettingsPath(), GetAppSettingsFilename())); } catch (Exception) { } }
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection props) { var values = new SettingsPropertyValueCollection(); foreach (SettingsProperty property in props) { var value2 = new SettingsPropertyValue(property) { IsDirty = false, SerializedValue = GetValue(property) }; values.Add(value2); } return values; }
public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection collection) { foreach (SettingsPropertyValue value in collection) { SettingsPropertyValue existing = SimpleSettingsStore.Instance.CurrentUserValues[value.Name]; if (existing == null) SimpleSettingsStore.Instance.CurrentUserValues.Add(existing = new SettingsPropertyValue(value.Property)); existing.PropertyValue = value.PropertyValue; } }
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection) { SettingsPropertyValueCollection spCollection = new SettingsPropertyValueCollection(); foreach (SettingsProperty settingsProperty in collection) { SettingsPropertyValue spVal = new SettingsPropertyValue(settingsProperty); spVal.PropertyValue = String.Empty; spCollection.Add(spVal); } return spCollection; }
public override SettingsPropertyValueCollection GetPropertyValues (SettingsContext context, SettingsPropertyCollection properties) { #if TARGET_JVM SettingsPropertyValueCollection pv = new SettingsPropertyValueCollection (); foreach (SettingsProperty prop in properties) pv.Add (new SettingsPropertyValue (prop)); return pv; #else return impl.GetPropertyValues (context, properties); #endif }
public void Add () { SettingsPropertyValueCollection col = new SettingsPropertyValueCollection (); SettingsProperty test_prop = new SettingsProperty ("test_prop"); SettingsPropertyValue val = new SettingsPropertyValue (test_prop); Assert.AreEqual (0, col.Count, "A1"); col.Add (val); Assert.AreEqual (1, col.Count, "A2"); }
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection) { CreateExeMap(); if (values == null) { values = new SettingsPropertyValueCollection(); LoadProperies(exeMapCurrent, collection, ConfigurationUserLevel.None, "applicationSettings", false); LoadProperies(exeMapCurrent, collection, ConfigurationUserLevel.None, "userSettings", false); LoadProperies(exeMapCurrent, collection, ConfigurationUserLevel.PerUserRoaming, "userSettings", true); LoadProperies(exeMapCurrent, collection, ConfigurationUserLevel.PerUserRoamingAndLocal, "userSettings", true); // create default values if not exist foreach (SettingsProperty p in collection) { if (values [p.Name] == null) { values.Add(new SettingsPropertyValue(p)); } } } return(values); }
private void GetPropertiesFromProvider(SettingsProvider provider) { SettingsPropertyCollection ppc = new SettingsPropertyCollection(); foreach (SettingsProperty pp in Properties) { if (pp.Provider == provider) { ppc.Add(pp); } } if (ppc.Count > 0) { SettingsPropertyValueCollection ppcv = provider.GetPropertyValues(Context, ppc); foreach (SettingsPropertyValue p in ppcv) { if (_PropertyValues[p.Name] == null) { _PropertyValues.Add(p); } } } }
private SettingsPropertyValueCollection GetSettingValuesFromFile(string configFileName, string sectionName, bool userScoped, SettingsPropertyCollection properties) { SettingsPropertyValueCollection values = new SettingsPropertyValueCollection(); IDictionary dictionary = ClientSettingsStore.ReadSettingsFromFile(configFileName, sectionName, userScoped); foreach (SettingsProperty property in properties) { string name = property.Name; SettingsPropertyValue value2 = new SettingsPropertyValue(property); if (dictionary.Contains(name)) { StoredSetting setting = (StoredSetting)dictionary[name]; string innerXml = setting.Value.InnerXml; if (setting.SerializeAs == SettingsSerializeAs.String) { innerXml = this.Escaper.Unescape(innerXml); } value2.SerializedValue = innerXml; value2.IsDirty = true; values.Add(value2); } } return(values); }
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection) { CreateExeMap(); values = new SettingsPropertyValueCollection(); string groupName = context ["GroupName"] as string; groupName = NormalizeInvalidXmlChars(groupName); // we likely saved the element removing the non valid xml chars. LoadProperties(exeMapCurrent, collection, ConfigurationUserLevel.None, "applicationSettings", false, groupName); LoadProperties(exeMapCurrent, collection, ConfigurationUserLevel.None, "userSettings", false, groupName); LoadProperties(exeMapCurrent, collection, ConfigurationUserLevel.PerUserRoaming, "userSettings", true, groupName); LoadProperties(exeMapCurrent, collection, ConfigurationUserLevel.PerUserRoamingAndLocal, "userSettings", true, groupName); // create default values if not exist foreach (SettingsProperty p in collection) { if (values [p.Name] == null) { values.Add(new SettingsPropertyValue(p)); } } return(values); }
public override void SetPropertyValues(System.Configuration.SettingsContext context, System.Configuration.SettingsPropertyValueCollection collection) {//JH string username = (string)context["UserName"]; bool isAuthenticated = (bool)context["IsAuthenticated"]; Guid uniqueID = GetUniqueID(username, isAuthenticated, false); SettingsPropertyValueCollection svc = new SettingsPropertyValueCollection(); foreach (SettingsProperty prop in collection) { SettingsPropertyValue pv = new SettingsPropertyValue(prop); svc.Add(pv); } activity(username, "Set property values", false); }
/// <summary> /// Sets Profile the property values. /// </summary> /// <param name="context">Profile context.</param> /// <param name="settingsPropertyValues">The settings profile property values.</param> public override void SetPropertyValues(System.Configuration.SettingsContext context, System.Configuration.SettingsPropertyValueCollection settingsPropertyValues) { string username = (string)context["UserName"]; bool isAuthenticated = (bool)context["IsAuthenticated"]; int userID = GetUniqueID(username, isAuthenticated); foreach (SettingsPropertyValue pv in settingsPropertyValues) { if (pv.IsDirty) { SetProperty(username, userID, isAuthenticated, (string)pv.Name, (string)pv.PropertyValue); } } }
/// <summary> /// Set/store the property values for the user profile. /// </summary> /// <param name="context">Application context.</param> /// <param name="settingsPropertyValues">Profile property value settings.</param> public override void SetPropertyValues(System.Configuration.SettingsContext context, System.Configuration.SettingsPropertyValueCollection settingsPropertyValues) { if (true == (bool)context["IsAuthenticated"]) { IObjectScope objScope = ORM.GetNewObjectScope(); string userName = GetUserName((string)context["UserName"]); objScope.Transaction.Begin(); EmployeeProfile ep = ResolveEmployeeProfileByName(objScope, userName); if (null == ep) { ep = new EmployeeProfile(); ep.Employee = ResolveEmployeeByName(objScope, userName); objScope.Add(ep); } foreach (SettingsPropertyValue settingsPropertyValue in settingsPropertyValues) { switch (settingsPropertyValue.Property.Name) { case "Language": ep.Language = settingsPropertyValue.PropertyValue as String; ep.LastUpdatedDate = DateTime.Now; break; case "StyleTheme": ep.StyleTheme = settingsPropertyValue.PropertyValue as String; ep.LastUpdatedDate = DateTime.Now; break; case "Factory_Name": ep.Factory_Name = settingsPropertyValue.PropertyValue as String; ep.LastUpdatedDate = DateTime.Now; break; case "Operation_Name": ep.Operation_Name = settingsPropertyValue.PropertyValue as String; ep.LastUpdatedDate = DateTime.Now; break; case "WorkCenter_Name": ep.WorkCenter_Name = settingsPropertyValue.PropertyValue as String; ep.LastUpdatedDate = DateTime.Now; break; default: throw new ProviderException("Unsupported property."); } } objScope.Transaction.Commit(); } }
public abstract void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection collection);
/// <summary> /// Sets the values of the specified group of property settings. /// </summary> /// <param name="context">A System.Configuration.SettingsContext describing the current application usage.</param> /// <param name="collection">A System.Configuration.SettingsPropertyValueCollection representing the group /// of property settings to set.</param> public void SetPropertyValues(System.Configuration.SettingsContext context, System.Configuration.SettingsPropertyValueCollection collection) { string username = (string)context["UserName"]; bool isAuthenticated = (bool)context["IsAuthenticated"]; // Get the profile for the current user name. Nequeo.DataAccess.CloudInteraction.Data.Profile profile = GetSpecificProfile(username); // If a profile exits. if (profile != null) { long profileID = profile.ProfileID; // For each property setting. foreach (SettingsPropertyValue pv in collection) { bool propertyFound = false; string propertyName = pv.Property.Name; // Get the value for the current property name. object value = GetProfilePropertyValue(profile, isAuthenticated, propertyName, out propertyFound); // If the property has been found. if (propertyFound) { // Update the property. bool retUpdate = new Nequeo.DataAccess.CloudInteraction.Data.Extension.ProfileValue(). Update.UpdateItemPredicate( new Data.ProfileValue() { PropertyValue = pv.PropertyValue.ToString() }, u => (u.ProfileID == profileID) && (u.PropertyName == propertyName) ); } else { // Insert the property. bool retInsert = new Nequeo.DataAccess.CloudInteraction.Data.Extension.ProfileValue(). Insert.InsertItem( new Data.ProfileValue() { ProfileID = profileID, PropertyName = propertyName, PropertyType = "System.String", PropertyValue = pv.PropertyValue.ToString() } ); } } // Updates the LastActivityDate and LastUpdatedDate values when profile properties UpdateActivityDates(username, isAuthenticated, false); } else { // Make sure that the profile exists for the username if authenticated. if (isAuthenticated) { throw new ProviderException("Profile username : "******" does not exist."); } } }
private void SaveProperties(ExeConfigurationFileMap exeMap, SettingsPropertyValueCollection collection, ConfigurationUserLevel level, SettingsContext context, bool checkUserLevel) { Configuration config = ConfigurationManager.OpenMappedExeConfiguration(exeMap, level); UserSettingsGroup userGroup = config.GetSectionGroup("userSettings") as UserSettingsGroup; bool isRoaming = (level == ConfigurationUserLevel.PerUserRoaming); if (userGroup == null) { userGroup = new UserSettingsGroup(); config.SectionGroups.Add("userSettings", userGroup); } ApplicationSettingsBase asb = context.CurrentSettings; string class_name = NormalizeInvalidXmlChars((asb != null ? asb.GetType() : typeof(ApplicationSettingsBase)).FullName); ClientSettingsSection userSection = null; ConfigurationSection cnf = userGroup.Sections.Get(class_name); userSection = cnf as ClientSettingsSection; if (userSection == null) { userSection = new ClientSettingsSection(); userGroup.Sections.Add(class_name, userSection); } bool hasChanges = false; if (userSection == null) { return; } foreach (SettingsPropertyValue value in collection) { if (checkUserLevel && value.Property.Attributes.Contains(typeof(SettingsManageabilityAttribute)) != isRoaming) { continue; } // The default impl does not save the ApplicationScopedSetting properties if (value.Property.Attributes.Contains(typeof(ApplicationScopedSettingAttribute))) { continue; } hasChanges = true; SettingElement element = userSection.Settings.Get(value.Name); if (element == null) { element = new SettingElement(value.Name, value.Property.SerializeAs); userSection.Settings.Add(element); } if (element.Value.ValueXml == null) { element.Value.ValueXml = new XmlDocument().CreateElement("value"); } switch (value.Property.SerializeAs) { case SettingsSerializeAs.Xml: element.Value.ValueXml.InnerXml = StripXmlHeader(value.SerializedValue as string); break; case SettingsSerializeAs.String: element.Value.ValueXml.InnerText = value.SerializedValue as string; break; case SettingsSerializeAs.Binary: element.Value.ValueXml.InnerText = value.SerializedValue != null?Convert.ToBase64String(value.SerializedValue as byte []) : string.Empty; break; default: throw new NotImplementedException(); } } if (hasChanges) { config.Save(ConfigurationSaveMode.Minimal, true); } }
/// <summary> /// Sets the property values. /// </summary> /// <param name="context">The context.</param> /// <param name="ppvc">The PPVC.</param> public override void SetPropertyValues(System.Configuration.SettingsContext context, System.Configuration.SettingsPropertyValueCollection ppvc) { MongoServer server = MongoServer.Create(connectionString); // connect to the mongoDB url. MongoDatabase ProviderDB = server.GetDatabase(pMongoProviderDatabaseName, SafeMode.True); MongoCollection <BsonDocument> profiles = ProviderDB.GetCollection(pMongoProviderProfileCollectionName); string username = (string)context["UserName"]; bool isAuthenticated = (bool)context["IsAuthenticated"]; // Create profile if does not exist. ObjectId existingProfileId = ObjectId.Empty; var query = Query.And(Query.EQ("ApplicationNameLowerCase", pApplicationName.ToLower()), Query.EQ("UsernameLowerCase", username.ToLower())); var existingProfile = profiles.FindOne(query); if (existingProfile != null) { existingProfileId = existingProfile["_id"].AsObjectId; } var profile = new BsonDocument(); profile.Add("ApplicationName", pApplicationName) .Add("ApplicationNameLowerCase", pApplicationName.ToLower()) .Add("Username", username) .Add("UsernameLowerCase", username.ToLower()) .Add("LastActivityDate", DateTime.Now) .Add("LastUpdatedDate", DateTime.Now) .Add("IsAnonymous", !isAuthenticated); if (existingProfileId != ObjectId.Empty) { profile.Add("_id", existingProfileId); } foreach (SettingsPropertyValue pv in ppvc) { profile.Add(pv.Name, BsonValue.Create(pv.PropertyValue)); } bool bSuccess = profiles.Save(profile).Ok; }
/// <summary> /// /// </summary> /// <param name="context"></param> /// <param name="collection"></param> public override void SetPropertyValues(System.Configuration.SettingsContext context, System.Configuration.SettingsPropertyValueCollection collection) { string userName = (string)context["UserName"]; bool isAnonymous = !(bool)context["IsAuthenticated"]; SettingsPropertyValueCollection propertyValues = new SettingsPropertyValueCollection(); using (var dataStore = new ProductStore(SqlHelper.Current.GetConnection(_connectionString))) { bool retry = true; int retryCount = 0; while (retry && retryCount < 2) { retryCount++; var profile = (from p in dataStore.Profile join d in dataStore.ProfileData on p.Id equals d.ProfileId where p.ApplicationName == ApplicationName && p.Username == userName select new { Profile = p, Data = d }).FirstOrDefault(); if (profile == null) { retry = true; CreateProfile(dataStore, userName); dataStore.SubmitChanges(); } else { retry = false; foreach (var property in collection) { SettingsPropertyValue settingsPropertyValue = property as SettingsPropertyValue; switch (settingsPropertyValue.Property.Name) { case "FirstName": profile.Data.FirstName = (string)settingsPropertyValue.PropertyValue; break; case "LastName": profile.Data.LastName = (string)settingsPropertyValue.PropertyValue; break; case "Phone": profile.Data.Phone = (string)settingsPropertyValue.PropertyValue; break; } } profile.Profile.LastUpdated = DateTime.Now; profile.Profile.LastActivity = DateTime.Now; dataStore.SubmitChanges(); } } } }
public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection values) { throw new NotImplementedException(); }
public override void SetPropertyValues(System.Configuration.SettingsContext context, System.Configuration.SettingsPropertyValueCollection collection) { //do notting, we cannot write properties to PSU Passport Service }
//----------------------------------------------------------------- #region --------------PrepareDataForSaving-------------- //------------------------------------------------------ //PrepareDataForSaving //------------------------------------------------------ internal static void PrepareDataForSaving(ref string allNames, ref string allValues, System.Configuration.SettingsPropertyValueCollection properties) { System.Text.StringBuilder stringBuilder1 = new System.Text.StringBuilder(); System.Text.StringBuilder stringBuilder2 = new System.Text.StringBuilder(); try { try { foreach (System.Configuration.SettingsPropertyValue settingsPropertyValue2 in properties) { if (settingsPropertyValue2.IsDirty || !settingsPropertyValue2.UsingDefaultValue) { int i1 = 0, i2 = 0; string s = null; if (settingsPropertyValue2.PropertyValue == null) { i1 = -1; } else { object obj = settingsPropertyValue2.PropertyValue; if (obj == null) { i1 = -1; } else { s = obj.ToString(); i1 = s.Length; i2 = stringBuilder2.Length; } } stringBuilder1.Append(settingsPropertyValue2.Name + ":" + (s != null ? "S" : "B") + ":" + i2.ToString() + ":" + i1.ToString() + ":"); if (s != null) { stringBuilder2.Append(s); } } } } finally { } } catch { throw; } allNames = stringBuilder1.ToString(); allValues = stringBuilder2.ToString(); }
//------------------------------------------------------ #endregion internal static void ParseProfileData(string PropertyNames, string PropertyValuesString, System.Configuration.SettingsPropertyValueCollection properties) { //------------------------------------------------------------- string[] names = null; string values = null; char[] chArr = new char[] { ':' }; names = PropertyNames.Split(chArr); values = PropertyValuesString; //------------------------------------------------------------- if ((names == null) || (values == null) || (properties == null)) { return; } try { for (int i1 = 0; i1 < (names.Length / 4); i1++) { string s = names[i1 * 4]; System.Configuration.SettingsPropertyValue settingsPropertyValue = properties[s]; if (settingsPropertyValue != null) { //int i2 = System.Int32.Parse(names[(i1 * 4) + 2], System.Globalization.CultureInfo.InvariantCulture); //int i3 = System.Int32.Parse(names[(i1 * 4) + 3], System.Globalization.CultureInfo.InvariantCulture); int i2 = System.Int32.Parse(names[(i1 * 4) + 2]); int i3 = System.Int32.Parse(names[(i1 * 4) + 3]); if ((i3 == -1) && !settingsPropertyValue.Property.PropertyType.IsValueType) { settingsPropertyValue.PropertyValue = null; settingsPropertyValue.IsDirty = false; //settingsPropertyValue.Deserialized = false; } //if (names[(i1 * 4) + 1] == "S\uFFFD" && (i2 >= 0) && (i3 > 0) && (values.Length >= (i2 + i3))) if (names[(i1 * 4) + 1] == "S" && (i2 >= 0) && (i3 > 0) && (values.Length >= (i2 + i3))) { settingsPropertyValue.PropertyValue = values.Substring(i2, i3); } //if (names[(i1 * 4) + 1] == "B\uFFFD" && (i2 >= 0) && (i3 > 0) && (buf.Length >= (i2 + i3))) } } } catch { } }
public override void SetPropertyValues(System.Configuration.SettingsContext context, System.Configuration.SettingsPropertyValueCollection collection) { throw new NotImplementedException(); }
/// <summary> /// Abstract SettingsProvider method /// </summary> public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection properties) { SettingsPropertyValueCollection values = new SettingsPropertyValueCollection(); string sectionName = GetSectionName(context); // Look for this section in both applicationSettingsGroup and userSettingsGroup IDictionary appSettings = Store.ReadSettings(sectionName, false); IDictionary userSettings = Store.ReadSettings(sectionName, true); ConnectionStringSettingsCollection connStrings = Store.ReadConnectionStrings(); // Now map each SettingProperty to the right StoredSetting and deserialize the value if found. foreach (SettingsProperty setting in properties) { string settingName = setting.Name; SettingsPropertyValue value = new SettingsPropertyValue(setting); // First look for and handle "special" settings SpecialSettingAttribute attr = setting.Attributes[typeof(SpecialSettingAttribute)] as SpecialSettingAttribute; bool isConnString = (attr != null) ? (attr.SpecialSetting == SpecialSetting.ConnectionString) : false; if (isConnString) { string connStringName = sectionName + "." + settingName; if (connStrings != null && connStrings[connStringName] != null) { value.PropertyValue = connStrings[connStringName].ConnectionString; } else if (setting.DefaultValue != null && setting.DefaultValue is string) { value.PropertyValue = setting.DefaultValue; } else { //No value found and no default specified value.PropertyValue = string.Empty; } value.IsDirty = false; //reset IsDirty so that it is correct when SetPropertyValues is called values.Add(value); continue; } // Not a "special" setting bool isUserSetting = IsUserSetting(setting); if (isUserSetting && !ConfigurationManagerInternalFactory.Instance.SupportsUserConfig) { // We encountered a user setting, but the current configuration system does not support // user settings. throw new ConfigurationErrorsException(SR.UserSettingsNotSupported); } IDictionary settings = isUserSetting ? userSettings : appSettings; if (settings.Contains(settingName)) { StoredSetting ss = (StoredSetting)settings[settingName]; string valueString = ss.Value.InnerXml; // We need to un-escape string serialized values if (ss.SerializeAs == SettingsSerializeAs.String) { valueString = Escaper.Unescape(valueString); } value.SerializedValue = valueString; } else if (setting.DefaultValue != null) { value.SerializedValue = setting.DefaultValue; } else { //No value found and no default specified value.PropertyValue = null; } value.IsDirty = false; //reset IsDirty so that it is correct when SetPropertyValues is called values.Add(value); } return(values); }
public override void SetPropertyValues(System.Configuration.SettingsContext context, System.Configuration.SettingsPropertyValueCollection collection) { using (UsersContext db = new UsersContext()) { string userName = context["UserName"].ToString(); UserProfile userProfile = db.UsersProfiles.Find(userName); if (userProfile == null) { userProfile = new UserProfile(); foreach (SettingsPropertyValue profilePropertyValue in collection) { userProfile.GetType().GetProperty(profilePropertyValue.Name).SetValue(userProfile, profilePropertyValue.PropertyValue, null); } db.UsersProfiles.Add(userProfile); } else { foreach (SettingsPropertyValue profilePropertyValue in collection) { userProfile.GetType().GetProperty(profilePropertyValue.Name).SetValue(userProfile, profilePropertyValue.PropertyValue, null); } } db.SaveChanges(); } }
private void SaveProperties(ExeConfigurationFileMap exeMap, SettingsPropertyValueCollection collection, ConfigurationUserLevel level, SettingsContext context, bool checkUserLevel) { Configuration config = ConfigurationManager.OpenMappedExeConfiguration(exeMap, level); UserSettingsGroup userGroup = config.GetSectionGroup("userSettings") as UserSettingsGroup; bool isRoaming = (level == ConfigurationUserLevel.PerUserRoaming); #if true // my reimplementation if (userGroup == null) { userGroup = new UserSettingsGroup(); config.SectionGroups.Add("userSettings", userGroup); ApplicationSettingsBase asb = context.CurrentSettings; ClientSettingsSection cs = new ClientSettingsSection(); string class_name = NormalizeInvalidXmlChars((asb != null ? asb.GetType() : typeof(ApplicationSettingsBase)).FullName); userGroup.Sections.Add(class_name, cs); } bool hasChanges = false; foreach (ConfigurationSection section in userGroup.Sections) { ClientSettingsSection userSection = section as ClientSettingsSection; if (userSection == null) { continue; } foreach (SettingsPropertyValue value in collection) { if (checkUserLevel && value.Property.Attributes.Contains(typeof(SettingsManageabilityAttribute)) != isRoaming) { continue; } // The default impl does not save the ApplicationScopedSetting properties if (value.Property.Attributes.Contains(typeof(ApplicationScopedSettingAttribute))) { continue; } hasChanges = true; SettingElement element = userSection.Settings.Get(value.Name); if (element == null) { element = new SettingElement(value.Name, value.Property.SerializeAs); userSection.Settings.Add(element); } if (element.Value.ValueXml == null) { element.Value.ValueXml = new XmlDocument().CreateElement("value"); } switch (value.Property.SerializeAs) { case SettingsSerializeAs.Xml: element.Value.ValueXml.InnerXml = (value.SerializedValue as string) ?? string.Empty; break; case SettingsSerializeAs.String: element.Value.ValueXml.InnerText = value.SerializedValue as string; break; case SettingsSerializeAs.Binary: element.Value.ValueXml.InnerText = value.SerializedValue != null?Convert.ToBase64String(value.SerializedValue as byte []) : string.Empty; break; default: throw new NotImplementedException(); } } } if (hasChanges) { config.Save(ConfigurationSaveMode.Minimal, true); } #else // original impl. - likely buggy to miss some properties to save foreach (ConfigurationSection configSection in userGroup.Sections) { ClientSettingsSection userSection = configSection as ClientSettingsSection; if (userSection != null) { /* * userSection.Settings.Clear(); * * foreach (SettingsPropertyValue propertyValue in collection) * { * if (propertyValue.IsDirty) * { * SettingElement element = new SettingElement(propertyValue.Name, SettingsSerializeAs.String); * element.Value.ValueXml = new XmlDocument(); * element.Value.ValueXml.InnerXml = (string)propertyValue.SerializedValue; * userSection.Settings.Add(element); * } * } */ foreach (SettingElement element in userSection.Settings) { if (collection [element.Name] != null) { if (collection [element.Name].Property.Attributes.Contains(typeof(SettingsManageabilityAttribute)) != isRoaming) { continue; } element.SerializeAs = SettingsSerializeAs.String; element.Value.ValueXml.InnerXml = (string)collection [element.Name].SerializedValue; ///Value = XmlElement } } } } config.Save(ConfigurationSaveMode.Minimal, true); #endif }
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection properties) { SettingsPropertyValueCollection values = new SettingsPropertyValueCollection(); string sectionName = this.GetSectionName(context); IDictionary dictionary = this.Store.ReadSettings(sectionName, false); IDictionary dictionary2 = this.Store.ReadSettings(sectionName, true); ConnectionStringSettingsCollection settingss = this.Store.ReadConnectionStrings(); foreach (SettingsProperty property in properties) { string name = property.Name; SettingsPropertyValue value2 = new SettingsPropertyValue(property); SpecialSettingAttribute attribute = property.Attributes[typeof(SpecialSettingAttribute)] as SpecialSettingAttribute; if ((attribute != null) ? (attribute.SpecialSetting == SpecialSetting.ConnectionString) : false) { string str3 = sectionName + "." + name; if ((settingss != null) && (settingss[str3] != null)) { value2.PropertyValue = settingss[str3].ConnectionString; } else if ((property.DefaultValue != null) && (property.DefaultValue is string)) { value2.PropertyValue = property.DefaultValue; } else { value2.PropertyValue = string.Empty; } value2.IsDirty = false; values.Add(value2); } else { bool flag2 = this.IsUserSetting(property); if (flag2 && !ConfigurationManagerInternalFactory.Instance.SupportsUserConfig) { throw new ConfigurationErrorsException(System.SR.GetString("UserSettingsNotSupported")); } IDictionary dictionary3 = flag2 ? dictionary2 : dictionary; if (dictionary3.Contains(name)) { StoredSetting setting = (StoredSetting)dictionary3[name]; string innerXml = setting.Value.InnerXml; if (setting.SerializeAs == SettingsSerializeAs.String) { innerXml = this.Escaper.Unescape(innerXml); } value2.SerializedValue = innerXml; } else if (property.DefaultValue != null) { value2.SerializedValue = property.DefaultValue; } else { value2.PropertyValue = null; } value2.IsDirty = false; values.Add(value2); } } return(values); }
public override void SetPropertyValues(SettingsContext context, SettingsPropertyValueCollection values) { impl.SetPropertyValues(context, values); }
protected SettingsBase() { _PropertyValues = new SettingsPropertyValueCollection(); }