public object MapToEditConfig(ConfigInstance config, ConfigurationSetModel model)
{
var configModel = model.Configs.Single(s => s.Type == config.ConfigType);
var source = config.GetConfiguration();
return(BuildObject(source, configModel.ConfigurationProperties));
}
private async Task HandleUploadRequest(HttpContext context, string clientid, ConfigurationSetModel configSetModel)
{
var input = await context.GetJObjectFromJsonBodyAsync();
var mappedConfigs = configurationSetUploadMapper.MapConfigurationSetUpload(input, configSetModel).ToArray();
var identity = new ConfigurationIdentity(clientid);
var validationResult = await ValidateConfigs(mappedConfigs, configSetModel, identity);
if (validationResult.IsValid)
{
foreach (var config in mappedConfigs)
{
var type = config.Value.GetType();
if (configSetModel.Get(type).IsReadOnly)
{
continue;
}
var instance = await configRepository.GetAsync(type, identity);
instance.SetConfiguration(config.Value);
await configRepository.UpdateConfigAsync(instance);
await eventService.Publish(new ConfigurationUpdatedEvent(instance));
}
responseFactory.BuildNoContentResponse(context);
}
else
{
responseFactory.BuildStatusResponse(context, 422);
}
}
/// <summary>
/// Adds new configuration set to the registry
/// </summary>
/// <param name="model">ConfigurationSetModel to be added to the registry</param>
/// <returns>returns true if successful or false if registry already contains configuration set type</returns>
public bool AddConfigurationSet(ConfigurationSetModel model)
{
if (collection.ContainsKey(model.ConfigSetType))
{
return(false);
}
collection.Add(model.ConfigSetType, model);
return(true);
}
public ConfigurationSetModelPayload Map(ConfigurationSetModel model)
{
return(new ConfigurationSetModelPayload
{
ConfigurationSetId = model.ConfigSetType.Name,
Name = model.Name,
Description = model.Description,
Config = BuildConfigs(model.Configs)
});
}
private ConfigurationSetSummary MapToSummary(ConfigurationSetModel model)
{
return(new ConfigurationSetSummary
{
ConfigurationSetId = model.ConfigSetType.Name,
Name = model.Name,
Description = model.Description,
Configs = model.Configs.Select(MapToSummary).ToList()
});
}
private async Task <object> GetConfigurationSet(ConfigurationSetModel model, ConfigurationClient client)
{
IDictionary <string, object> result = new ExpandoObject();
var configurationSet = await configurationSetService.GetConfigurationSet(model.ConfigSetType, new ConfigurationIdentity(client, configCollection.GetVersion()));
foreach (var configModel in model.Configs)
{
result[configModel.Name] = configModel.GetConfigurationFromConfigurationSet(configurationSet);
}
return(result);
}
private async Task <object> GetConfigurationSet(ConfigurationSetModel model, string clientId)
{
IDictionary <string, object> configurationSet = new ExpandoObject();
foreach (var configModel in model.Configs)
{
var config = await configRepository.GetAsync(configModel.Type, new ConfigurationIdentity { ClientId = clientId });
configurationSet[configModel.Name] = config.GetConfiguration();
}
return(configurationSet);
}
public async Task <ConfigurationSetModelPayload> Map(ConfigurationSetModel model, ConfigurationIdentity configIdentity)
{
var configurationSets = await GetRequiredConfiguration(model, configIdentity);
return(new ConfigurationSetModelPayload
{
ConfigurationSetId = model.ConfigSetType.Name,
Name = model.Name,
Description = model.Description,
Config = BuildConfigs(model.Configs, configIdentity, configurationSets)
});
}
private async Task BuildConfigurations(ConfigurationSet result, ConfigurationSetModel setDefinition, Type setType, IEnumerable <ConfigurationSet> configurationSets, ConfigurationIdentity identity)
{
var configurationDependencies = configurationSets.Concat(new[] { result }).ToArray();
foreach (var configDefinition in setDefinition.Configs.Where(w => !(w is ConfigurationOptionModel)))
{
var configInstance = await configProvider.GetAsync(configDefinition.Type, identity);
var configuration = configInstance.GetConfiguration();
UpdateOptions(configuration, configDefinition.ConfigurationProperties, configurationDependencies, identity);
configDefinition.SetConfigurationOnConfigurationSet(result, configuration);
}
}
private ConfigurationSetSummary MapToSummary(ConfigurationSetModel model)
{
return(new ConfigurationSetSummary
{
ConfigurationSetId = model.ConfigSetType.Name,
Name = model.Name,
Description = model.Description,
RequiredClientTag = model.RequiredClientTag?.Value,
Configs = model.Configs.Where(w => !w.IsReadOnly)
.Select(MapToSummary)
.ToList()
});
}
private async Task BuildOptions(ConfigurationSet result, ConfigurationSetModel setDefinition, Type setType, IEnumerable <ConfigurationSet> configurationSets, ConfigurationIdentity identity)
{
var configurationDependencies = configurationSets.Concat(new[] { result }).ToArray();
foreach (var option in GetOptionsInOrder(setDefinition))
{
IOptionSet optionSet;
if (option is ReadOnlyConfigurationOptionModel readonlyModel)
{
optionSet = optionSetFactory.Build(readonlyModel, identity);
}
else
{
optionSet = await BuildOptionSetCollection(option, configurationDependencies, identity);
}
option.SetConfigurationOnConfigurationSet(result, optionSet);
}
}
private async Task HandleUploadRequest(HttpContext context, string clientid, ConfigurationSetModel configSetModel)
{
var input = await context.GetJObjectFromJsonBodyAsync();
var mappedConfigs = configurationSetUploadMapper.MapConfigurationSetUpload(input, configSetModel).ToArray();
var validationResult = ValidateConfigs(mappedConfigs, configSetModel);
if (validationResult.IsValid)
{
foreach (var config in mappedConfigs)
{
var instance = await configRepository.GetAsync(config.Value.GetType(), new ConfigurationIdentity { ClientId = clientid });
instance.SetConfiguration(config.Value);
await configRepository.UpdateConfigAsync(instance);
}
responseFactory.BuildNoContentResponse(context);
}
else
{
responseFactory.BuildStatusResponse(context, 422);
}
}
private IEnumerable <ConfigurationOptionModel> GetOptionsInOrder(ConfigurationSetModel setDefinition)
{
var optionLookup = setDefinition.Configs.OfType <ConfigurationOptionModel>().ToDictionary(k => k.Name);
var dependenciesLookup = optionLookup.ToDictionary(k => k.Key, v => v.Value.GetDependencies()
.Where(w => w.ConfigurationSet == setDefinition.ConfigSetType)
.Select(s => s.PropertyPath)
.Distinct()
.ToList());
if (dependenciesLookup.Any(r => r.Value.Contains(r.Key)))
{
throw new Exception("Circular Dependencies of Options Detected");
}
var handledOption = new HashSet <string>();
while (optionLookup.Count != 0)
{
var removedItems = new List <string>();
foreach (var option in optionLookup)
{
var dependencies = dependenciesLookup[option.Key];
dependencies.RemoveAll(handledOption.Contains);
if (dependencies.Count != 0)
{
continue;
}
handledOption.Add(option.Key);
removedItems.Add(option.Key);
yield return(option.Value);
}
foreach (var item in removedItems)
{
optionLookup.Remove(item);
}
}
}
public async Task <ConfigInstance> UpdateConfigurationInstance(ConfigInstance original, JContainer newEditPayload, ConfigurationSetModel model)
{
var configModel = model.Configs.Single(s => s.Type == original.ConfigType);
var identity = new ConfigurationIdentity(original.ClientId);
var configurationSets = await GetRequiredConfiguration(model, identity);
var newConfig = UpdateObject(original, newEditPayload, configModel, identity, configurationSets);
original.SetConfiguration(newConfig);
return(original);
}
private async Task <ValidationResult> ValidateConfigs(IEnumerable <KeyValuePair <string, object> > source, ConfigurationSetModel configSetModel, ConfigurationIdentity configIdentity)
{
var validationResults = source.Select(async kvp => await confgiurationValidator.Validate(kvp.Value, configSetModel.Configs.Single(s => s.Name == kvp.Key), configIdentity)).ToArray();
await Task.WhenAll(validationResults);
return(new ValidationResult(validationResults.Select(s => s.Result)));
}
private ValidationResult ValidateConfigs(IEnumerable <KeyValuePair <string, object> > source, ConfigurationSetModel configSetModel)
{
var validationResults = source.Select(kvp => confgiurationValidator.Validate(kvp.Value, configSetModel.Configs.Single(s => s.Name == kvp.Key)));
return(new ValidationResult(validationResults));
}
public ConfigInstance UpdateConfigurationInstance(ConfigInstance original, JObject newEditPayload, ConfigurationSetModel model)
{
var configModel = model.Configs.Single(s => s.Type == original.ConfigType);
var newConfig = UpdateObject(original.ConstructNewConfiguration(), newEditPayload, configModel.ConfigurationProperties);
original.SetConfiguration(newConfig);
return(original);
}
internal ConfigurationSetModelBuilder(string name, string description)
{
definition = new ConfigurationSetModel <TConfigurationSet>(name, description);
}
internal ConfigurationSetModelBuilder(string name, string description)
{
definition = new ConfigurationSetModel(typeof(TConfigurationSet), name, description);
}
public IEnumerable <KeyValuePair <string, object> > MapConfigurationSetUpload(string upload, ConfigurationSetModel model)
{
var jObject = JObject.Parse(upload);
foreach (var item in model.Configs.Where(w => !w.IsReadOnly))
{
if (!jObject.TryGetValue(item.Name, StringComparison.OrdinalIgnoreCase, out var configJToken))
{
continue;
}
var config = configurationUploadMapper.ToObjectOrDefault(configJToken.ToString(), item);
yield return(new KeyValuePair <string, object>(item.Name, config));
}
}
/// <summary> /// Adds new configuration set to the registry /// </summary> /// <param name="model">ConfigurationSetModel to be added to the registry</param> /// <returns>returns true if successful or false if registry already contains configuration set type</returns> public bool AddConfigurationSet(ConfigurationSetModel model) => registry.AddConfigurationSet(model);
private async Task <IEnumerable <ConfigurationSet> > GetRequiredConfiguration(ConfigurationSetModel model, ConfigurationIdentity identity)
{
var requiredConfigurationSetTypes = model.GetDependencies()
.Select(s => s.ConfigurationSet)
.Distinct()
.ToArray();
var configurationSet = new ConfigurationSet[requiredConfigurationSetTypes.Length];
var i = 0;
foreach (var type in requiredConfigurationSetTypes)
{
configurationSet[i] = await configurationSetService.GetConfigurationSet(type, identity);
i++;
}
return(configurationSet);
}
private async Task <ConfigInstance> GetConfigInstance(HttpContext context, ConfigInstance configInstance, ConfigurationSetModel model)
{
if (configInstance.IsCollection)
{
var input = await context.GetJArrayFromJsonBodyAsync();
return(await configurationUpdatePayloadMapper.UpdateConfigurationInstance(configInstance, input, model));
}
else
{
var input = await context.GetJObjectFromJsonBodyAsync();
return(await configurationUpdatePayloadMapper.UpdateConfigurationInstance(configInstance, input, model));
}
}
/// <summary> /// Tries to get definition for configuration set type /// </summary> /// <param name="type">configuration set type to be retrieved</param> /// <param name="result">ConfigurationModel for selected configuration set type</param> /// <returns>True if found else false</returns> public bool TryGetConfigSetDefinition(Type type, out ConfigurationSetModel result) => collection.TryGetValue(type, out result);
public IEnumerable <KeyValuePair <string, object> > MapConfigurationSetUpload(JObject upload, ConfigurationSetModel model)
{
foreach (var item in model.Configs)
{
if (!upload.TryGetValue(item.Name, StringComparison.OrdinalIgnoreCase, out var configJToken))
{
continue;
}
var config = ToObjectOrDefault(configJToken, item.Type);
yield return(new KeyValuePair <string, object>(item.Name, config));
}
}
