public virtual async Task SetAsync(string name, string value, string providerName, string providerKey, bool forceToSet = false)
{
Check.NotNull(name, nameof(name));
Check.NotNull(providerName, nameof(providerName));
var setting = SettingDefinitionManager.Get(name);
var providers = Enumerable
.Reverse(Providers)
.SkipWhile(p => p.Name != providerName)
.ToList();
if (!providers.Any())
{
return;
}
if (setting.IsEncrypted)
{
value = SettingEncryptionService.Encrypt(setting, value);
}
if (providers.Count > 1 && !forceToSet && setting.IsInherited && value != null)
{
var fallbackValue = await GetOrNullInternalAsync(name, providers[1].Name, null).ConfigureAwait(false);
if (fallbackValue == value)
{
//Clear the value if it's same as it's fallback value
value = null;
}
}
providers = providers
.TakeWhile(p => p.Name == providerName)
.ToList(); //Getting list for case of there are more than one provider with same providerName
if (value == null)
{
foreach (var provider in providers)
{
await provider.ClearAsync(setting, providerKey).ConfigureAwait(false);
}
}
else
{
foreach (var provider in providers)
{
await provider.SetAsync(setting, value, providerKey).ConfigureAwait(false);
}
}
}
public virtual async Task <string> GetOrNullAsync(string name)
{
var setting = SettingDefinitionManager.Get(name);
var providers = Enumerable
.Reverse(SettingValueProviderManager.Providers);
if (setting.Providers.Any())
{
providers = providers.Where(p => setting.Providers.Contains(p.Name));
}
//TODO: How to implement setting.IsInherited?
var value = await GetOrNullValueFromProvidersAsync(providers, setting);
if (value != null && setting.IsEncrypted)
{
value = SettingEncryptionService.Decrypt(setting, value);
}
return(value);
}
protected virtual async Task <string> GetOrNullInternalAsync(string name, string providerName, string providerKey, bool fallback = true)
{
var setting = SettingDefinitionManager.Get(name);
var providers = Enumerable
.Reverse(Providers);
if (providerName != null)
{
providers = providers.SkipWhile(c => c.Name != providerName);
}
if (!fallback || !setting.IsInherited)
{
providers = providers.TakeWhile(c => c.Name == providerName);
}
string value = null;
foreach (var provider in providers)
{
value = await provider.GetOrNullAsync(
setting,
provider.Name == providerName?providerKey : null
).ConfigureAwait(false);
if (value != null)
{
break;
}
}
if (setting.IsEncrypted)
{
value = SettingEncryptionService.Decrypt(setting, value);
}
return(value);
}
public virtual async Task <List <SettingValue> > GetAllAsync(string[] names)
{
var result = new Dictionary <string, SettingValue>();
var settingDefinitions = SettingDefinitionManager.GetAll().Where(x => names.Contains(x.Name)).ToList();
foreach (var definition in settingDefinitions)
{
result.Add(definition.Name, new SettingValue(definition.Name, null));
}
foreach (var provider in Enumerable.Reverse(SettingValueProviderManager.Providers))
{
var settingValues = await provider.GetAllAsync(settingDefinitions.Where(x => !x.Providers.Any() || x.Providers.Contains(provider.Name)).ToArray());
var notNullValues = settingValues.Where(x => x.Value != null).ToList();
foreach (var settingValue in notNullValues)
{
var settingDefinition = settingDefinitions.First(x => x.Name == settingValue.Name);
if (settingDefinition.IsEncrypted)
{
settingValue.Value = SettingEncryptionService.Decrypt(settingDefinition, settingValue.Value);
}
if (result.ContainsKey(settingValue.Name) && result[settingValue.Name].Value == null)
{
result[settingValue.Name].Value = settingValue.Value;
}
}
settingDefinitions.RemoveAll(x => notNullValues.Any(v => v.Name == x.Name));
if (!settingDefinitions.Any())
{
break;
}
}
return(result.Values.ToList());
}
public virtual async Task <List <SettingValue> > GetAllAsync(string providerName, string providerKey, bool fallback = true)
{
Check.NotNull(providerName, nameof(providerName));
var settingDefinitions = SettingDefinitionManager.GetAll();
var providers = Enumerable.Reverse(Providers)
.SkipWhile(c => c.Name != providerName);
if (!fallback)
{
providers = providers.TakeWhile(c => c.Name == providerName);
}
var providerList = providers.Reverse().ToList();
if (!providerList.Any())
{
return(new List <SettingValue>());
}
var settingValues = new Dictionary <string, SettingValue>();
foreach (var setting in settingDefinitions)
{
string value = null;
if (setting.IsInherited)
{
foreach (var provider in providerList)
{
var providerValue = await provider.GetOrNullAsync(
setting,
provider.Name == providerName?providerKey : null
).ConfigureAwait(false);
if (providerValue != null)
{
value = providerValue;
}
}
}
else
{
value = await providerList[0].GetOrNullAsync(
setting,
providerKey
).ConfigureAwait(false);
}
if (setting.IsEncrypted)
{
value = SettingEncryptionService.Decrypt(setting, value);
}
if (value != null)
{
settingValues[setting.Name] = new SettingValue(setting.Name, value);
}
}
return(settingValues.Values.ToList());
}
