private IList <SettingKey> SaveSettings(IEnumerable <KeyValuePair <SettingKey, SettingItem> > values) { List <SettingKey> keys = new List <SettingKey>(); using (IUnitOfWork work = ServiceProvider.GetService <IDataContextFactory>().Get().Create()) { IRepository <SettingData> repository = work.For <SettingData>(); foreach (var pair in values) { SettingKey key = pair.Key; IProxyType <string> value = pair.Value; try { if (AddOrUpdateSetting(repository, key, value)) { keys.Add(key); } } catch (Exception ex) { Logger.Instance.LogFormat(LogType.Error, this, Properties.Resources.SettingAddOrUpdateError, key); Logger.Instance.LogException(this, ex); } } work.Commit(); } return(keys); }
/// <summary> /// Accepts a value that is either a comma-separated list of DUNS numbers or in the form @filename in which /// filename is a file containing DUNS numbers /// </summary> /// <param name="Key"></param> /// <param name="Value"></param> /// <returns></returns> public override bool Accept(string Key, string Value) { if (Key.ToLower() == SettingKey.ToLower()) { if (Value != string.Empty && Value.Substring(0, 1) == "@") { using (StreamReader sr = new StreamReader(Value.Substring(1))) { while ((Value = sr.ReadLine()) != null) { SettingValue.AddRange(Value.Split(',')); SettingInitialized = true; } } } else { SettingValue.AddRange(Value.Split(',')); SettingInitialized = true; } SettingValue.RemoveAll(Str => string.IsNullOrEmpty(Str)); // ensure there are no empties return(true); } return(false); }
void ISettingsServiceInternal.SetSetting(string identifier, string name, SettingItem value) { try { Assertions.AssertNotEmpty(identifier, "identifier"); Assertions.AssertNotEmpty(name, "name"); IEnumerable <SettingKey> savedSettings = null; lock (SyncRoot) { SettingKey key = SettingKey.Create(identifier, name); List <KeyValuePair <SettingKey, SettingItem> > settings = new List <KeyValuePair <SettingKey, SettingItem> >(); settings.Add(new KeyValuePair <SettingKey, SettingItem>(key, value)); savedSettings = SaveSettings(settings); } if (savedSettings != null && savedSettings.Any()) { OnSettingChanged(new SettingChangedEventArgs(savedSettings)); } } catch (Exception ex) { throw AlarmWorkflowFaultDetails.CreateFault(ex); } }
public SettingItem GetSetting(SettingKey key) { Console.WriteLine($"Requested setting {key.Identifier}.{key.Name}."); if (key.Name == "PrintingQueueNames") { return(new SettingItem(key.Identifier, key.Name, _defaultPrinter, typeof(string))); } if (key.Name == "PrintingQueuesConfiguration") { var setting = new PrintingQueuesConfiguration { Entries = { new PrintingQueue { Name = _defaultPrinter, IsEnabled = true, CopyCount = 1, PrinterName = _defaultPrinter } } }; return(new SettingItem(key.Identifier, key.Name, (setting as IStringSettingConvertible).ConvertBack(), typeof(PrintingQueuesConfiguration))); } if (key.Name == "TemplateFile") { return(new SettingItem(key.Identifier, key.Name, Path.GetFullPath(@"Resources\OperationPrintTemplate_NonStatic.htm"), typeof(string))); } if (key.Name == "ScriptTimeout") { return(new SettingItem(key.Identifier, key.Name, "60", typeof(int))); } return(null); }
public EndManagerBase(ISettingsManager settings, SettingKey endpointKey) { this.settings = settings; this.key = endpointKey; var savedIndex = LoadIndex(); Index = savedIndex < 0 ? EndpointsData.THIS_DEVICE : savedIndex; EndpointsData.BeforeRemoval += e => { if (ActiveEndpoint == e) { Index = EndpointsData.THIS_DEVICE; } }; EndpointsData.EndpointModified += e => { if (ActiveEndpoint == e) { ActivateEndpoint(e); } }; ActiveEndpointChanged += async e => { try { await CheckServerVersion(e); } catch (Exception) { } }; }
public void RemoveEntry(string section, string entry) { SettingKey key = new SettingKey(section, entry); cache.Remove(key); provider.RemoveEntry(section, entry); }
public Task RemoveAsync(SettingKey settingKey, SettingGroupKey settingGroupKey, CancellationToken cancellationToken) { return(_msSqlConnection.ExecuteAsync( cancellationToken, DeleteSql, new { Key = settingKey.Value, GroupKey = settingGroupKey.Value })); }
protected virtual async Task <Setting> GetSettingEntityAsync(SettingKey key) { var namespaceAttribute = GetEnumAttribute <NamespaceAttribute>(key); var namespaceValue = namespaceAttribute?.Namespace ?? Setting.DefaultNamespace; return(await _settingsRepository.FindByIdAsync(namespaceValue, key)); }
public async Task <DescribedSettingDto> GetSettingAsync(SettingKey key) { var setting = await GetSettingEntityAsync(key); DescribedSettingDto settingDto; if (setting == null) { var descriptionAttribute = GetEnumAttribute <DescriptionAttribute>(key); settingDto = new DescribedSettingDto { Description = descriptionAttribute?.Description, Key = key }; } else { settingDto = _mapper.Map <DescribedSettingDto>(setting); } var defaultValueAttribute = GetEnumAttribute <DefaultValueAttribute>(key); settingDto.DefaultValue = defaultValueAttribute?.Value?.ToString(); return(settingDto); }
private void SetSetting(SettingKey key, object value) { setSettingCommand.Parameters[0].Value = key.ToString(); setSettingCommand.Parameters[1].Value = value; setSettingCommand.ExecuteNonQuery(); settings[key] = value; }
public async Task <IActionResult> GetShareByKeyAsync([FromQuery] SettingKey key) { var repo = _uowCore.GetRepository <ISettingRepository>(); var setting = await repo.GetByKeyAsync(key.ToString()); return(Ok(setting)); }
public void SetValue(string section, string entry, object value) { SettingKey key = new SettingKey(section, entry); cache.Remove(key); cache.Add(key, value); provider.SetValue(section, entry, value); }
private void ClosePluginKey() { if (SettingKey != null) { SettingKey.Dispose(); SettingKey = null; } }
public static string Get(this SettingKey key) { return (DatabaseFactory.Instance.Settings .Where(x => x.Key == key) .Select(x => x.Value) .FirstOrDefault()); }
private void SaveSetting(SettingKey skey, string value) { lock (skey.lockObj) { this.settings[skey.key] = value; this.settings.Save(); } }
public override bool Accept(string Key, Stack <string> CmdLineArgs) { if (Key.ToLower() == SettingKey.ToLower() && CmdLineArgs.Count > 0) { return(Accept(Key, CmdLineArgs.Pop())); } return(false); }
public override bool Accept(string Key, Stack <string> CmdLineArgs) { if (Key.ToLower() == SettingKey.ToLower()) { return(Accept(Key, string.Empty)); } return(false); }
protected virtual T GetEnumAttribute <T>(SettingKey key) where T : Attribute { var enumType = key.GetType(); var keyInfo = enumType.GetMember(key.ToString()) .FirstOrDefault(member => member.DeclaringType == enumType); return(keyInfo?.GetCustomAttribute <T>()); }
public ISettingEditor CreateEditorFor(SettingKey key) { if (key.Type == typeof(EnvironmentCollection)) { return(new EnvironmentCollectionEditor(_factories.Select(x => x.Value))); } return(null); }
protected virtual async Task <string> GetSettingValueAsync(SettingKey key) { var setting = await GetSettingEntityAsync(key); var defaultValueAttribute = GetEnumAttribute <DefaultValueAttribute>(key); var defaultValue = defaultValueAttribute?.Value?.ToString(); return(setting?.Value ?? defaultValue); }
public override bool Accept(string Key, string Value) { if (Key.ToLower() == SettingKey.ToLower()) { SettingValue = Value; SettingInitialized = true; return(true); } return(false); }
public async Task <Setting> UpdateSetting(int portalId, SettingKey key, string value) { Setting dbSetting = await GetSettingByKey(portalId, key); dbSetting.Value = value; await Context.SaveChangesAsync(); return(dbSetting); }
private static void DeleteSetting(string valueName) { try { SettingKey?.DeleteValue(valueName, false); } catch { } }
public async Task <TimeSpan> GetTimeSpanAsync(SettingKey key) { if (!TimeSpan.TryParse(await GetSettingValueAsync(key), out var timeSpan)) { var defaultValueAttribute = GetEnumAttribute <DefaultValueAttribute>(key); timeSpan = TimeSpan.Parse(defaultValueAttribute?.Value?.ToString() ?? "0"); } return(timeSpan); }
// public methods // set setting value, update underlying file if AutoUpdate is true public void SetValue(SettingKey key, object value) { // update internal list _list[key.ToString()] = value; // update settings file if (_autoWrite) { Write(); } }
public override bool Accept(string Key, string Value) { if (Key.ToLower() == SettingKey.ToLower()) { SettingValue = new List <string>(Value.Split(',')); SettingInitialized = true; return(true); } return(false); }
public override bool Accept(string Key, string Value) { if (Key.ToLower() == SettingKey.ToLower()) { SettingValue = Value == string.Empty ? SettingValue : Int32.Parse(Value); SettingInitialized = true; return(true); } return(false); }
public async Task <string> GetAsync(SettingKey settingKey, SettingGroupKey settingGroupKey, CancellationToken cancellationToken) { var values = await _msSqlConnection.QueryAsync <string>( cancellationToken, GetSql, new { Key = settingKey.Value, GroupKey = settingGroupKey.Value }) .ConfigureAwait(false); return(values.SingleOrDefault()); }
private static void SetSettingKey(string valueName, object value, RegistryValueKind kind) { try { SettingKey?.SetValue(valueName, value, kind); } catch { } }
public async Task Ping([FromBody] TenantMessage tenantMessage, CancellationToken cancellationToken) { await _settingApi.SetAsync(SettingKey.With("last-ping-message"), tenantMessage.Text, cancellationToken).ConfigureAwait(false); var reply = tenantMessage.CreateReply( "pong", TenantMessageAttachmentProperty.With("text", tenantMessage.Text), TenantMessageAttachmentProperty.With("color", "#333333")); await _messageApi.SendAsync(reply, cancellationToken).ConfigureAwait(false); }
SettingItem ISettingsServiceInternal.GetSetting(SettingKey key) { Assertions.AssertNotNull(key, "key"); SettingItem item = _settings.GetSetting(key.Identifier, key.Name); lock (SyncRoot) { ApplySettingValue(key.Identifier, key.Name, item); } return item; }
void ISettingsServiceCallback.OnSettingChanged(SettingKey[] keys) { try { var copy = SettingsChanged; if (copy != null) { copy(keys); } } catch (Exception ex) { // Callback methods shall always have a no-throw guarantee! Logger.Instance.LogException(this, ex); } }
private static bool AddOrUpdateSetting(IRepository<SettingData> repository, SettingKey key, IProxyType<string> value) { SettingData setting = repository.Query.FirstOrDefault(_ => _.Identifier == key.Identifier && _.Name == key.Name); if (setting == null) { setting = new SettingData(); setting.Identifier = key.Identifier; setting.Name = key.Name; repository.Insert(setting); } string valueToPersist = value.ProxiedValue; if (!string.Equals(setting.Value, valueToPersist, StringComparison.Ordinal)) { setting.Value = valueToPersist; return true; } return false; }
private void Remember(string section, string entry, object value) { SettingKey key = new SettingKey(section, entry); cache.Add(key, value); }
public async Task<BaseSettingModel> GetSettingByKeyAsync(SettingKey key) { await Initialize(); return SettingManager.GetAllSettings().FirstOrDefault(s => s.SettingKey == key); }
private static void ModifyConfigItem(SettingKey key, String value) { InitSettingInfoMapping(); try { rwlock.EnterWriteLock(); if (settingInfoMapping.ContainsKey(key)) settingInfoMapping[key] = value; else settingInfoMapping.Add(key, value); SaveConfig(HttpRuntime.AppDomainAppPath + settingFileName); } finally { rwlock.ExitWriteLock(); } }
private static string LoadConfigItem(SettingKey key) { InitSettingInfoMapping(); try { rwlock.EnterReadLock(); if (!settingInfoMapping.ContainsKey(key)) return string.Empty; return settingInfoMapping[key]; } finally { rwlock.ExitReadLock(); } }
void ISettingsServiceCallback.OnSettingChanged(SettingKey[] keys) { // TODO: Update setting values }
public async Task<BaseSettingModel> GetSettingByKeyAsync(SettingKey key) { return _sampleSettings.FirstOrDefault(s => s.SettingKey == key); }
private static bool AddOrUpdateSetting(SettingsEntities entities, SettingKey key, IProxyType<string> value) { UserSettingData userSetting = entities.GetUserSettingData(key.Identifier, key.Name); if (userSetting == null) { userSetting = new UserSettingData(); userSetting.Identifier = key.Identifier; userSetting.Name = key.Name; entities.UserSettings.AddObject(userSetting); } string valueToPersist = value.ProxiedValue; if (!string.Equals(userSetting.Value, valueToPersist, StringComparison.Ordinal)) { userSetting.Value = valueToPersist; return true; } return false; }
SettingItem ISettingsServiceInternal.GetSetting(SettingKey key) { try { Assertions.AssertNotNull(key, "key"); SettingItem item = _settings.GetSetting(key.Identifier, key.Name); lock (SyncRoot) { ApplySettingValue(key.Identifier, key.Name, item); } return item; } catch (Exception ex) { throw AlarmWorkflowFaultDetails.CreateFault(ex); } }
public object GetValue(string section, string entry) { SettingKey key = new SettingKey(section, entry); object obj; if (!cache.TryGetValue(key, out obj)) { cacheMiss++; obj = provider.GetValue(section, entry); cache.Add(key, obj); } else { cacheHit++; } return obj; }