public SettingsExplorer(ApplicationSettingsBase settings)
: base(new Guid("B760CC2A-F836-403E-9BD5-17807A387A8E"))
{
_settings = settings;
Functions = ExplorerFunctions.GetContent | ExplorerFunctions.SetText;
var type = _settings.GetType();
Location = Far.Api.GetModuleManager(type).ModuleName + "\\" + type.Name;
foreach (SettingsProperty property in _settings.Properties)
{
// skip not browsable
var browsable = (BrowsableAttribute)property.Attributes[typeof(BrowsableAttribute)];
if (browsable != null && !browsable.Browsable)
{
continue;
}
// ensure the property value exists
var dummy = _settings[property.Name];
var value = _settings.PropertyValues[property.Name];
var file = new SetFile();
_files.Add(file);
file.Data = value;
file.Name = property.Name;
file.Description = GetPropertyValueText(value);
CompleteFileData(file, value);
}
}
public static void ImportSharedSettings(this ApplicationSettingsBase settings, string configurationFilename)
{
SystemConfiguration configuration = SystemConfigurationHelper.GetExeConfiguration(configurationFilename);
var values = SystemConfigurationHelper.GetSettingsValues(configuration, settings.GetType());
SetSharedPropertyValues(settings, values);
}
static public string Txt(ApplicationSettingsBase appSettings, string settingName)
{
return(Txt(
appSettings,
_nilnul.cfg.on_._DllX.Cfg(appSettings.GetType().Assembly)
, settingName
));
}
public static ReactiveProperty <T> ToReactiveProperty <T>(this ApplicationSettingsBase settings, string propertyName)
{
var propertyInfo = settings.GetType().GetProperty(propertyName);
var reactiveProperty = new ReactiveProperty <T>((T)propertyInfo.GetValue(settings));
settings.PropertyChanged += (s, e) => reactiveProperty.Value = (T)propertyInfo.GetValue(settings);
reactiveProperty.Subscribe(t => propertyInfo.SetValue(settings, t));
return(reactiveProperty);
}
// PortableSettingsProvider code obtained from http://stackoverflow.com/a/2579399 (Accessed 02-01-2014 @ 17:04).
private static void MakeSettingsPortable(ApplicationSettingsBase settings)
{
var portableSettingsProvider = new PortableSettingsProvider(settings.GetType().Name + ".settings");
settings.Providers.Add(portableSettingsProvider);
foreach (SettingsProperty prop in settings.Properties)
{
prop.Provider = portableSettingsProvider;
}
settings.Reload();
}
/// <summary>
/// Gets the default property value by property name.
/// </summary>
/// <typeparam name="T">Type to which the property must be cast to in the end.</typeparam>
/// <param name="settings">The application settings.</param>
/// <param name="propertyName">Name of the property we want to get the default value from.</param>
/// <returns></returns>
public static T GetPropertyDefaultValueByName <T>(this ApplicationSettingsBase settings, string propertyName)
{
var settingsProperty = settings.Properties[propertyName];
var propertyInfo = settings.GetType().GetProperties().FirstOrDefault(p => string.Equals(p.Name, propertyName, StringComparison.InvariantCulture));
if (propertyInfo == null || settingsProperty == null)
{
return(default(T));
}
return((T)Convert.ChangeType(settingsProperty.DefaultValue, propertyInfo.PropertyType));
}
public static void Export(ApplicationSettingsBase config, string path)
{
XDocument xml = new XDocument(new XElement("DV_ReportAnalytics"));
var props = config.GetType().GetProperties(
BindingFlags.DeclaredOnly |
BindingFlags.Instance |
BindingFlags.Public);
foreach (var p in props)
{
xml.Root.Add(new XElement(p.Name, p.GetValue(config)));
}
xml.Save(path);
}
private void Form_Load(object sender, EventArgs e)
{
if (_appSettings == null)
{
return;
}
PropertyInfo settingProperty = _appSettings.GetType().GetProperty(_settingName);
if (settingProperty == null)
{
return;
}
WindowSettings previousSettings = settingProperty.GetValue(_appSettings, null) as WindowSettings;
if (previousSettings == null)
{
return;
}
previousSettings.Restore(this);
}
public static void Import(ApplicationSettingsBase config, string path)
{
XDocument xml = XDocument.Load(path);
try
{
// validate config before importing
const string typeParam = "ReportType";
string configType = (string)config.GetType().GetProperty(typeParam).GetValue(config);
string xmlType = xml.Root.Element(typeParam).Value;
if (!string.Equals(configType, xmlType))
{
throw new Exception();
}
// starting importing
var props = config.GetType().GetProperties(
BindingFlags.DeclaredOnly |
BindingFlags.Instance |
BindingFlags.Public);
foreach (var p in props)
{
if (p.Name == typeParam)
{
continue;
}
var pt = p.PropertyType;
p.SetValue(config, Convert.ChangeType(xml.Root.Element(p.Name).Value, pt));
}
}
catch
{
string errormsg = "Invalid config!";
Console.WriteLine(errormsg);
ExceptionThrown?.Invoke(Default, new EventArgs <string>(errormsg));
}
}
/// <summary>
/// Resets the settings that correspond to the defined section to its default values.
/// </summary>
/// <param name="settings">The application defualt settings (extension method)</param>
/// <param name="section">The section type</param>
public static void ResetSectionToDefaultValues(this ApplicationSettingsBase settings, PropertyGroup.SettingsGroup section)
{
foreach (var propertyInfo in settings.GetType().GetProperties())
{
var att = propertyInfo.GetCustomAttributes(typeof(PropertyGroup), true).FirstOrDefault();
if (att == null || ((PropertyGroup)att).Value != section)
{
continue;
}
var settingsProperty = settings.Properties[propertyInfo.Name];
if (settingsProperty == null)
{
continue;
}
propertyInfo.SetValue(settings, Convert.ChangeType(settingsProperty.DefaultValue, propertyInfo.PropertyType), null);
}
}
public static bool Unprotect(this ApplicationSettingsBase settings)
{
var config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.PerUserRoamingAndLocal);
var sec = config.GetSectionGroup("userSettings")?.Sections[settings.GetType().FullName];
if (sec != null)
{
try
{
if (sec.SectionInformation.IsProtected)
{
sec.SectionInformation.UnprotectSection();
config.Save(ConfigurationSaveMode.Minimal);
}
return(true);
}
catch
{
}
}
return(false);
}
public static void LoadFromServiceCore(ApplicationSettingsBase target)
{
try
{
Settings @default = Settings.Default;
Type type = @default.GetType();
Type type2 = target.GetType();
Dictionary <string, string> dictionary = new Dictionary <string, string>();
foreach (PropertyInfo propertyInfo in type.GetProperties())
{
object[] customAttributes = propertyInfo.GetCustomAttributes(typeof(SpecialSettingAttribute), false);
int j = 0;
while (j < customAttributes.Length)
{
SpecialSettingAttribute specialSettingAttribute = (SpecialSettingAttribute)customAttributes[j];
if (specialSettingAttribute.SpecialSetting == SpecialSetting.ConnectionString)
{
string text = propertyInfo.GetValue(@default, null) as string;
if (text != null)
{
dictionary.Add(propertyInfo.Name, StringEncrypter.Decrypt(text, propertyInfo.Name, false));
@default[propertyInfo.Name] = dictionary[propertyInfo.Name];
break;
}
Log <ConnectionStringLoader> .Logger.FatalFormat("Fail to read {0} in ServiceCore", propertyInfo.Name);
break;
}
else
{
j++;
}
}
}
foreach (PropertyInfo propertyInfo2 in type2.GetProperties())
{
bool flag = false;
object[] customAttributes2 = propertyInfo2.GetCustomAttributes(typeof(SpecialSettingAttribute), false);
int l = 0;
while (l < customAttributes2.Length)
{
SpecialSettingAttribute specialSettingAttribute2 = (SpecialSettingAttribute)customAttributes2[l];
if (specialSettingAttribute2.SpecialSetting == SpecialSetting.ConnectionString)
{
flag = true;
string text2 = dictionary.TryGetValue(propertyInfo2.Name);
if (text2 != null)
{
target[propertyInfo2.Name] = text2;
break;
}
Log <ConnectionStringLoader> .Logger.FatalFormat("No connectionstring defined in ServiceCore : {0}", propertyInfo2.Name);
break;
}
else
{
l++;
}
}
if (!flag && (propertyInfo2.GetCustomAttributes(typeof(ApplicationScopedSettingAttribute), false).FirstOrDefault <object>() != null || propertyInfo2.GetCustomAttributes(typeof(UserScopedSettingAttribute), false).FirstOrDefault <object>() != null))
{
Log <ConnectionStringLoader> .Logger.FatalFormat("Do NOT define Configuration Setting outside of ServiceCore : {0}", propertyInfo2.Name);
}
}
}
catch (Exception ex)
{
Log <ConnectionStringLoader> .Logger.Fatal(string.Format("Exception occurred while loading ConnectionStrings : {0}", target), ex);
}
}