public Settings(IServiceProvider provider)
{
SettingsManager settingsManager = new ShellSettingsManager(provider);
_settingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings);
if (!_settingsStore.CollectionExists("DebugAttachManagerProcesses"))
{
return;
}
IEnumerable <string> services = _settingsStore.GetSubCollectionNames("DebugAttachManagerProcesses");
foreach (var s in services)
{
var p = new StoredProcessInfo
{
ProcessName = _settingsStore.GetString("DebugAttachManagerProcesses\\" + s, "ProcessName"),
Title = _settingsStore.PropertyExists("DebugAttachManagerProcesses\\" + s, "Title") ?
_settingsStore.GetString("DebugAttachManagerProcesses\\" + s, "Title") : null,
RemoteServerName = _settingsStore.PropertyExists("DebugAttachManagerProcesses\\" + s, "RemoteServerName") ?
_settingsStore.GetString("DebugAttachManagerProcesses\\" + s, "RemoteServerName") : null,
RemotePortNumber = _settingsStore.PropertyExists("DebugAttachManagerProcesses\\" + s, "RemotePortNumber") ?
_settingsStore.GetInt64("DebugAttachManagerProcesses\\" + s, "RemotePortNumber") : (long?)null,
Selected = _settingsStore.GetBoolean("DebugAttachManagerProcesses\\" + s, "Selected"),
DebugMode = _settingsStore.PropertyExists("DebugAttachManagerProcesses\\" + s, "DebugMode") ?
_settingsStore.GetString("DebugAttachManagerProcesses\\" + s, "DebugMode") : null
};
Processes.Add(p.Hash, p);
}
if (_settingsStore.PropertyExists("DebugAttachManagerProcesses", "RemoteServer"))
{
RemoteServer = _settingsStore.GetString("DebugAttachManagerProcesses", "RemoteServer");
}
}
public static string GetTemplate(TestFramework testFramework, MockFramework mockFramework, TemplateType templateType)
{
string templateSettingKey = GetTemplateSettingsKey(testFramework, mockFramework, templateType);
if (Store.PropertyExists(CollectionPath, templateSettingKey))
{
return(Store.GetString(CollectionPath, templateSettingKey));
}
switch (templateType)
{
case TemplateType.File:
var templateGenerator = new DefaultTemplateGenerator();
return(templateGenerator.Get(testFramework, mockFramework));
case TemplateType.MockFieldDeclaration:
return(mockFramework.MockFieldDeclarationCode);
case TemplateType.MockFieldInitialization:
return(mockFramework.MockFieldInitializationCode);
case TemplateType.MockObjectReference:
return(mockFramework.MockObjectReferenceCode);
default:
throw new ArgumentOutOfRangeException(nameof(templateType), templateType, null);
}
}
private void UpdateSettings()
{
string configVersion = null;
if (_settingsStore.PropertyExists(CollectionPath, SettingsVersionPropertyName))
{
configVersion = _settingsStore.GetString(CollectionPath, SettingsVersionPropertyName);
}
if (configVersion == null)
{
try
{
var connections = new List <ConnectionDetail>();
var deprecatedConnectionsXml = _settingsStore.GetString(CollectionPath, ConnectionsPropertyName);
var deprecatedConnections = (List <McTools.Xrm.Connection.Deprecated.ConnectionDetail>)XmlSerializerHelper.Deserialize(deprecatedConnectionsXml, typeof(List <McTools.Xrm.Connection.Deprecated.ConnectionDetail>));
foreach (var connection in deprecatedConnections)
{
connections.Add(UpdateConnection(connection));
}
var connectionsXml = XmlSerializerHelper.Serialize(connections);
_settingsStore.SetString(CollectionPath, ConnectionsPropertyName, connectionsXml);
_settingsStore.SetString(CollectionPath, SettingsVersionPropertyName, CurrentConfigurationVersion);
}
catch (Exception ex)
{
Logger.Write("Failed to convert connections: " + ex.Message);
}
}
}
public static string GetTemplate(MockFramework mockFramework, TemplateType templateType)
{
string templateSettingKey = GetTemplateSettingsKey(mockFramework, templateType);
if (Store.PropertyExists(CollectionPath, templateSettingKey))
{
return(Store.GetString(CollectionPath, GetTemplateSettingsKey(mockFramework, templateType)));
}
return(GetDefaultTemplate(mockFramework, templateType));
}
private T GetEnum <T>(string settingName, T defaultValue)
{
if (!_userSettingsStore.PropertyExists(SettingsPropName, settingName))
{
return(defaultValue);
}
var setting = _userSettingsStore.GetString(SettingsPropName, settingName);
var rval = (T)Enum.Parse(typeof(T), setting);
return(rval);
}
/// <summary>
/// Reads and parses Crm Connections from settings store
/// </summary>
/// <returns>Returns Crm Connetions</returns>
private CrmConnections GetCrmConnections()
{
if (_settingsStore.PropertyExists(CollectionPath, ConnectionsPropertyName) == false)
{
return(null);
}
var connectionsXml = _settingsStore.GetString(CollectionPath, ConnectionsPropertyName);
try
{
var connections = XmlSerializerHelper.Deserialize <List <ConnectionDetail> >(connectionsXml);
var crmConnections = new CrmConnections {
Connections = connections
};
var publisAfterUpload = true;
if (_settingsStore.PropertyExists(CollectionPath, AutoPublishPropertyName))
{
publisAfterUpload = _settingsStore.GetBoolean(CollectionPath, AutoPublishPropertyName);
}
crmConnections.PublishAfterUpload = publisAfterUpload;
var ignoreExtensions = false;
if (_settingsStore.PropertyExists(CollectionPath, IgnoreExtensionsProprtyName))
{
ignoreExtensions = _settingsStore.GetBoolean(CollectionPath, IgnoreExtensionsProprtyName);
}
crmConnections.IgnoreExtensions = ignoreExtensions;
var extendedLog = false;
if (_settingsStore.PropertyExists(CollectionPath, ExtendedLogProprtyName))
{
extendedLog = _settingsStore.GetBoolean(CollectionPath, ExtendedLogProprtyName);
}
crmConnections.ExtendedLog = extendedLog;
foreach (var connection in crmConnections.Connections)
{
if (!string.IsNullOrEmpty(connection.UserPassword))
{
connection.UserPassword = DecryptString(connection.UserPassword);
}
}
return(crmConnections);
}
catch (Exception)
{
Logger.WriteLine("Failed to parse connection settings");
return(null);
}
}
public static void LoadSettings(ISettings settings)
{
try
{
if (store.CollectionExists(settings.Key) != true)
{
return;
}
var type = settings.GetType();
foreach (var prop in type.GetProperties().Where(p => Attribute.IsDefined(p, typeof(SettingAttribute))))
{
if (prop.PropertyType == typeof(bool))
{
if (store.PropertyExists(settings.Key, prop.Name))
{
prop.SetValue(settings, store.GetBoolean(settings.Key, prop.Name));
}
}
else if (prop.PropertyType == typeof(int))
{
if (store.PropertyExists(settings.Key, prop.Name))
{
prop.SetValue(settings, store.GetInt32(settings.Key, prop.Name));
}
}
else if (prop.PropertyType == typeof(double))
{
if (store.PropertyExists(settings.Key, prop.Name))
{
double.TryParse(store.GetString(settings.Key, prop.Name), out double value);
prop.SetValue(settings, value);
}
}
else if (prop.PropertyType == typeof(string))
{
if (store.PropertyExists(settings.Key, prop.Name))
{
prop.SetValue(settings, store.GetString(settings.Key, prop.Name));
}
}
}
}
catch (Exception ex)
{
Debug.Fail(ex.Message);
}
}
private void LoadSettings()
{
// IsDesignerEnabled, either read from the store or initialize to true.
IsDesignerEnabled = !_store.PropertyExists(COLLECTION_PATH, IS_DESIGNER_ENABLED_PROPERTY) || _store.GetBoolean(COLLECTION_PATH, IS_DESIGNER_ENABLED_PROPERTY);
SplitOrientation = _store.PropertyExists(COLLECTION_PATH, SPLIT_ORIENTATION_PROPERTY)
? (SplitOrientation)_store.GetInt32(COLLECTION_PATH, SPLIT_ORIENTATION_PROPERTY)
: SplitOrientation.Default;
DocumentView = _store.PropertyExists(COLLECTION_PATH, DOCUMENT_VIEW_PROPERTY)
? (DocumentView)_store.GetInt32(COLLECTION_PATH, DOCUMENT_VIEW_PROPERTY)
: DocumentView.SplitView;
IsReversed = _store.PropertyExists(COLLECTION_PATH, IS_REVERSED_PROPERTY) && _store.GetBoolean(COLLECTION_PATH, IS_REVERSED_PROPERTY);
}
public bool WriteStringData(string key, string value)
{
try
{
if (!_writableSettingsStore.CollectionExists(tasCollectionPath))
{
_writableSettingsStore.CreateCollection(tasCollectionPath);
}
_writableSettingsStore.SetString(tasCollectionPath, key, value);
if (_writableSettingsStore.PropertyExists(tasCollectionPath, key))
{
return(true);
}
else
{
throw new Exception($"Tried to write value \"{value}\" to user settings store property \"{key}\" but no such property existed after writing.");
}
}
catch (Exception ex)
{
_logger.Error(ex.Message);
return(false);
}
}
public bool GetBoolean(string propertyName)
{
try
{
if (_settingsStore.PropertyExists(CollectionPath, propertyName))
{
return(_settingsStore.GetBoolean(CollectionPath, propertyName));
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return(false);
}
private static void CreatePropertyIfDoesNotExist <T>(string propertyName)
{
if (!_userSettingsStore.PropertyExists(CollectionName, propertyName))
{
WriteSetting(propertyName, default(T));
}
}
private static void LoadSettingsFromStore(ISettings settings)
{
var properties = GetProperties(settings);
foreach (var prop in properties)
{
if (store.PropertyExists(settings.Key, prop.Name))
{
switch (prop.GetValue(settings))
{
case bool b:
prop.SetValue(settings, store.GetBoolean(settings.Key, prop.Name));
break;
case int i:
prop.SetValue(settings, store.GetInt32(settings.Key, prop.Name));
break;
case double d when double.TryParse(store.GetString(settings.Key, prop.Name), out double value):
prop.SetValue(settings, value);
break;
case string s:
prop.SetValue(settings, store.GetString(settings.Key, prop.Name));
break;
}
}
}
}
public FormsPlayerViewModel([Import(typeof(SVsServiceProvider))] IServiceProvider services)
{
ConnectCommand = new DelegateCommand(Connect, () => !isConnected);
DisconnectCommand = new DelegateCommand(Disconnect, () => isConnected);
events = services.GetService <DTE>().Events.DocumentEvents;
events.DocumentSaved += document => Publish(document.FullName);
var manager = new ShellSettingsManager(services);
settings = manager.GetWritableSettingsStore(SettingsScope.UserSettings);
if (!settings.CollectionExists(SettingsPath))
{
settings.CreateCollection(SettingsPath);
}
if (settings.PropertyExists(SettingsPath, SettingsKey))
{
SessionId = settings.GetString(SettingsPath, SettingsKey, "");
}
if (string.IsNullOrEmpty(SessionId))
{
// Initialize SessionId from MAC address.
var mac = NetworkInterface.GetAllNetworkInterfaces()
.Where(nic => nic.NetworkInterfaceType != NetworkInterfaceType.Loopback)
.Select(nic => nic.GetPhysicalAddress().ToString())
.First();
SessionId = NaiveBijective.Encode(NaiveBijective.Decode(mac));
}
TaskScheduler.UnobservedTaskException += OnTaskException;
}
static StaticBoilerplateSettings()
{
SettingsManager settingsManager = new ShellSettingsManager(ServiceProvider.GlobalProvider);
Store = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings);
Store.CreateCollection(CollectionPath);
if (Store.PropertyExists(CollectionPath, TestProjectsKey))
{
string dictionaryString = Store.GetString(CollectionPath, TestProjectsKey);
if (string.IsNullOrEmpty(dictionaryString))
{
TestProjectsDictionary = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
}
else
{
TestProjectsDictionary = new Dictionary <string, string>(JsonConvert.DeserializeObject <Dictionary <string, string> >(dictionaryString), StringComparer.OrdinalIgnoreCase);
}
}
else
{
TestProjectsDictionary = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
}
}
public Task <SettingsModel> GetSettingsAsync()
{
return(System.Threading.Tasks.Task.Run(() =>
{
try
{
if (_writableSettingsStore.PropertyExists(CollectionPath, PropertyName))
{
var settingsString = _writableSettingsStore.GetString(CollectionPath, PropertyName);
return JsonConvert.DeserializeObject <SettingsModel>(settingsString);
}
}
catch (Exception ex)
{
Debug.Fail(ex.Message);
}
return new SettingsModel()
{
WorkItemTypes = new List <SettingItemModel>(),
WorkItemStatuses = new List <SettingItemModel>(),
Columns = new List <SettingItemModel>(),
DaysBackToQuery = 10,
MaxWorkItems = 8
};
}));
}
/// <summary>
/// Deletes property from settings store if it exists within specified collection
/// </summary>
/// <param name="store">Extending class</param>
/// <param name="collectionPath">Path of the collection of the property</param>
/// <param name="propertyName">Name of the property</param>
public static void DeletePropertyIfExists(this WritableSettingsStore store, string collectionPath, string propertyName)
{
if (store.PropertyExists(collectionPath, propertyName))
{
store.DeleteProperty(collectionPath, propertyName);
}
}
private static void EnsureSettingsStore(WritableSettingsStore settingsStore)
{
if (!settingsStore.CollectionExists(SettingsCollection))
{
settingsStore.CreateCollection(SettingsCollection);
}
if (!settingsStore.PropertyExists(SettingsCollection, ToolchainProperty))
{
settingsStore.SetString(SettingsCollection, ToolchainProperty, ToolchainDefault);
}
if (!settingsStore.PropertyExists(SettingsCollection, RustupPathProperty))
{
settingsStore.SetString(SettingsCollection, RustupPathProperty, RustupPathDefault);
}
}
private object Get(string key, Type targetType = null, object defaultValue = null, SerializationMode serializationMode = SerializationMode.Xml)
{
try
{
if (targetType == null)
{
targetType = ConvertSettingsType(Check.TryCatch <SettingsType, Exception>(() => settingsStore.GetPropertyType(collectionPath, key)));
}
object result = null;
if (targetType.IsEnum)
{
targetType = typeof(int);
}
if (targetType == typeof(bool))
{
result = settingsStore.GetBoolean(collectionPath, key, Convert.ToBoolean(defaultValue));
}
else if (targetType == typeof(string))
{
result = settingsStore.GetString(collectionPath, key, defaultValue as string);
}
else if (targetType == typeof(int))
{
result = settingsStore.GetInt32(collectionPath, key, Convert.ToInt32(defaultValue));
}
else
{
if (settingsStore.PropertyExists(collectionPath, key))
{
if (serializationMode == SerializationMode.Xml)
{
string xmlContent = settingsStore.GetString(collectionPath, key);
var serializer = new XmlSerializer(targetType);
MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(xmlContent));
var res = serializer.Deserialize(ms);
return(res);
}
else
{
var ms = settingsStore.GetMemoryStream(collectionPath, key);
if (ms != null)
{
var serializer = new BinaryFormatter();
result = serializer.Deserialize(ms);
}
}
}
}
return(result ?? defaultValue);
}
catch (Exception)
{
return(defaultValue);
}
}
public string ReadOption(string key)
{
if (_settingsStore.PropertyExists(SettingsRoot, key))
{
return(_settingsStore.GetString(SettingsRoot, key));
}
return(null);
}
internal bool GetBoolean(string propertyName, bool defaultValue)
{
EnsureCollectionExists();
try
{
if (!_settingsStore.PropertyExists(CollectionPath, propertyName))
{
return(defaultValue);
}
return(_settingsStore.GetBoolean(CollectionPath, propertyName));
}
catch (Exception e)
{
Report(String.Format(ErrorGetFormat, propertyName), e);
return(defaultValue);
}
}
private static void RemoveExtensionFromPendingDeletions(WritableSettingsStore settingsStore, IExtensionHeader extensionHeader)
{
const string PendingDeletionsCollectionPath = ExtensionManagerCollectionPath + @"\PendingDeletions";
var vsixToDeleteProperty = $"{extensionHeader.Identifier},{extensionHeader.Version}";
if (settingsStore.CollectionExists(PendingDeletionsCollectionPath) &&
settingsStore.PropertyExists(PendingDeletionsCollectionPath, vsixToDeleteProperty))
{
settingsStore.DeleteProperty(PendingDeletionsCollectionPath, vsixToDeleteProperty);
}
}
public string LoadString(string name, string category)
{
var path = GetCollectionPath(category);
if (!_settingsStore.CollectionExists(path)) {
return null;
}
if (!_settingsStore.PropertyExists(path, name)) {
return null;
}
return _settingsStore.GetString(path, name, "");
}
internal VersionProvider(IServiceProvider serviceProvider)
{
var settingsManager = new ShellSettingsManager(serviceProvider);
_settingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings);
if (!_settingsStore.CollectionExists(CollectionName))
_settingsStore.CreateCollection(CollectionName);
if (_settingsStore.PropertyExists(CollectionName, OldVersionPropertyName))
_settingsStore.DeleteProperty(CollectionName, OldVersionPropertyName);
}
/// <summary>
/// Returns the value of the requested property whose data type is System.Uri
/// </summary>
/// <param name="store">Extending class</param>
/// <param name="collectionPath">Path of the collection of the property</param>
/// <param name="propertyName">Name of the property</param>
/// <returns>Uri or null if not set or not valid uri</returns>
public static Uri GetUri(this WritableSettingsStore store, string collectionPath, string propertyName)
{
if (store.PropertyExists(collectionPath, propertyName))
{
Uri uri = null;
string value = store.GetString(collectionPath, propertyName);
Uri.TryCreate(value, UriKind.Absolute, out uri);
return(uri);
}
return(null);
}
/// <summary>
/// Loads the indent size from the settings store.
/// </summary>
/// <param name="store">The writable settings store</param>
/// <returns>The indent size saved or if not found, the default indent size</returns>
public static int LoadIndentSize(this WritableSettingsStore store)
{
if (!store.PropertyExists(collectionName, indentSizePropertyName))
{
store.SaveIndentSize(DefaultRainbowIndentOptions.defaultIndentSize);
return(DefaultRainbowIndentOptions.defaultIndentSize);
}
else
{
return(store.GetInt32(collectionName, indentSizePropertyName));
}
}
public static void InitWritableSettings(this WritableSettingsStore settingsStore)
{
if (!settingsStore.CollectionExists(PackageSettingsCategory))
{
settingsStore.CreateCollection(PackageSettingsCategory);
}
if (!settingsStore.PropertyExists(PackageSettingsCategory, PackageReadyPropertyName))
{
settingsStore.SetBoolean(PackageSettingsCategory, PackageReadyPropertyName, false);
}
}
/// <summary>
/// Loads the color string from the settings store
/// </summary>
/// <param name="store">The writable settings store</param>
/// <returns>´The colors string or if not found, the default colors</returns>
public static string LoadColors(this WritableSettingsStore store)
{
if (!store.PropertyExists(collectionName, colorsPropertyName))
{
store.SaveColors(DefaultRainbowIndentOptions.defaultColors);
return(DefaultRainbowIndentOptions.defaultColors);
}
else
{
return(store.GetString(collectionName, colorsPropertyName));
}
}
public static void LoadCurrent()
{
try
{
if (!settingsStore.CollectionExists(COLLECTION_PATH))
{
return;
}
if (settingsStore.PropertyExists(COLLECTION_PATH, nameof(FontSettings.Font)))
{
CurrentSettings.Font = settingsStore.GetString(COLLECTION_PATH, nameof(FontSettings.Font));
}
if (settingsStore.PropertyExists(COLLECTION_PATH, nameof(FontSettings.Size)))
{
var str = settingsStore.GetString(COLLECTION_PATH, nameof(FontSettings.Size));
double size;
double.TryParse(str, out size);
CurrentSettings.Size = size;
}
if (settingsStore.PropertyExists(COLLECTION_PATH, nameof(FontSettings.Italic)))
{
CurrentSettings.Italic = settingsStore.GetBoolean(COLLECTION_PATH, nameof(FontSettings.Italic));
}
if (settingsStore.PropertyExists(COLLECTION_PATH, nameof(FontSettings.Opacity)))
{
var str = settingsStore.GetString(COLLECTION_PATH, nameof(FontSettings.Opacity));
double opacity;
double.TryParse(str, out opacity);
CurrentSettings.Opacity = opacity;
}
}
catch (Exception ex)
{
Debug.Fail(ex.Message);
}
}
public Task <SettingsModel> GetSettingsAsync()
{
return(Task.Run(() =>
{
try
{
// migrate classic storage to newer TeamProjectCollection-based storage
if (_writableSettingsStore.PropertyExists(CollectionPath, ClassicPropertyName))
{
var settingsString = _writableSettingsStore.GetString(CollectionPath, ClassicPropertyName);
SaveSetingsString(settingsString);
_writableSettingsStore.DeleteProperty(CollectionPath, ClassicPropertyName);
}
}
catch (Exception ex)
{
Debug.Fail(ex.Message);
}
return GetSettingsModel();
}));
}
public BoilerplateSettingsFactory()
{
this.dte = (DTE2)ServiceProvider.GlobalProvider.GetService(typeof(DTE));
this.personalSettings = new BoilerplateSettings(this.personalStore);
SettingsManager settingsManager = new ShellSettingsManager(ServiceProvider.GlobalProvider);
WritableSettingsStore store = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings);
store.CreateCollection(PersonalBoilerplateSettingsStore.CollectionPath);
if (store.PropertyExists(PersonalBoilerplateSettingsStore.CollectionPath, UserBoilerplateSettings))
{
UserCreatedSettingsPath = store.GetString(PersonalBoilerplateSettingsStore.CollectionPath, UserBoilerplateSettings);
}
}
/// <summary>
/// Returns the value of the requested property whose data type is System.Guid
/// </summary>
/// <param name="store">Extending class</param>
/// <param name="collectionPath">Path of the collection of the property</param>
/// <param name="propertyName">Name of the property</param>
/// <returns>Guid or null if not set or not valid uri</returns>
public static Guid?GetGuid(this WritableSettingsStore store, string collectionPath, string propertyName)
{
if (store.PropertyExists(collectionPath, propertyName))
{
var guid = Guid.Empty;
var value = store.GetString(collectionPath, propertyName);
if (Guid.TryParse(value, out guid))
{
return(guid);
}
}
return(null);
}