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;
}
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 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);
}
public void RemoveEntry(string section, string entry)
{
SettingKey key = new SettingKey(section, entry);
cache.Remove(key);
provider.RemoveEntry(section, entry);
}
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;
}
