private ScopeSpecification CreateScopeSpecification(VariableScopeValues scopeValues, bool shouldPrompt)
{
IEnumerable <string> machines = new string[0];
IEnumerable <string> actions = new string[0];
IEnumerable <string> roles = new string[0];
IEnumerable <string> channels = new string[0];
IEnumerable <string> tenantTags = new string[0];
var maxNumberOfScopeValues = _maximumNumberOfScopeValues.Get();
var environments = new SubsetProbability <ReferenceDataItem>(0, maxNumberOfScopeValues, scopeValues.Environments).Get().Select(x => x.Id);
if (!shouldPrompt)
{
machines = new SubsetProbability <ReferenceDataItem>(0, maxNumberOfScopeValues, scopeValues.Machines).Get().Select(x => x.Id);
actions = new SubsetProbability <ReferenceDataItem>(0, maxNumberOfScopeValues, scopeValues.Actions).Get().Select(x => x.Id);
roles = new SubsetProbability <ReferenceDataItem>(0, maxNumberOfScopeValues, scopeValues.Roles).Get().Select(x => x.Id);
channels = new SubsetProbability <ReferenceDataItem>(0, maxNumberOfScopeValues, scopeValues.Channels).Get().Select(x => x.Id);
tenantTags = new SubsetProbability <ReferenceDataItem>(0, maxNumberOfScopeValues, scopeValues.TenantTags).Get().Select(x => x.Id);
}
return(new ScopeSpecification
{
{ ScopeField.Environment, new ScopeValue(environments) },
{ ScopeField.Machine, new ScopeValue(machines) },
{ ScopeField.Action, new ScopeValue(actions) },
{ ScopeField.Role, new ScopeValue(roles) },
{ ScopeField.Channel, new ScopeValue(channels) },
{ ScopeField.TenantTag, new ScopeValue(tenantTags) },
});
}
VariableScopeValues UpdateScopeValues(IDictionary <string, EnvironmentResource> environments, IDictionary <string, MachineResource> machines, IDictionary <string, ChannelResource> channels, IDictionary <ScopeField, List <ReferenceDataItem> > scopeValuesUsed)
{
var scopeValues = new VariableScopeValues();
Log.Debug("Updating the Environments of the Variable Sets Scope Values");
scopeValues.Environments = new List <ReferenceDataItem>();
foreach (var environment in scopeValuesUsed[ScopeField.Environment])
{
var newEnvironment = environments[environment.Id];
scopeValues.Environments.Add(new ReferenceDataItem(newEnvironment.Id, newEnvironment.Name));
}
Log.Debug("Updating the Machines of the Variable Sets Scope Values");
scopeValues.Machines = new List <ReferenceDataItem>();
foreach (var machine in scopeValuesUsed[ScopeField.Machine])
{
var newMachine = machines[machine.Id];
scopeValues.Machines.Add(new ReferenceDataItem(newMachine.Id, newMachine.Name));
}
Log.Debug("Updating the Channels of the Variable Sets Scope Values");
scopeValues.Channels = new List <ReferenceDataItem>();
foreach (var channel in scopeValuesUsed[ScopeField.Channel])
{
var newChannel = channels[channel.Id];
scopeValues.Channels.Add(new ReferenceDataItem(newChannel.Id, newChannel.Name));
}
return(scopeValues);
}
private static IEnumerable <ReferenceDataItem> GetScopeValues(VariableScopeValues scopeValues, ScopeField scopeField)
{
switch (scopeField)
{
case ScopeField.Environment:
return(scopeValues.Environments);
case ScopeField.Machine:
return(scopeValues.Machines);
default:
return(new ReferenceDataItem[] { });
}
}
private List <VariableResource> CreateVariablesForVariableSet(VariableScopeValues variableSetScopeValues, int numberOfVariables)
{
return(Enumerable.Range(0, numberOfVariables).Select(i =>
{
var variable = new VariableResource()
{
Name = $"{GenerateSomeVariableName()}",
IsEditable = true
};
bool shouldPrompt = _shouldPrompt.Get();
if (shouldPrompt)
{
variable.Prompt = new VariablePromptOptions()
{
Description = GenerateSomeVariableDescription(),
Label = GenerateSomeVariableName(),
Required = _required.Get()
};
}
variable.Scope = CreateScopeSpecification(variableSetScopeValues, shouldPrompt);
// TODO: Add certificates
// For new, only string and password types are supported
bool isString = _isStringVariable.Get();
if (isString)
{
variable.Type = VariableType.String;
variable.Value = shouldPrompt ? string.Empty : GenerateSomeVariableValue();
}
else
{
variable.Type = VariableType.Sensitive;
variable.Value = shouldPrompt ? string.Empty : GenerateSomeVariableValue();
}
return variable;
}).ToList());
}
protected Dictionary <ScopeField, List <ReferenceDataItem> > GetScopeValuesUsed(IList <VariableResource> variables, IList <DeploymentStepResource> steps, VariableScopeValues variableScopeValues)
{
var usedScopeValues = new Dictionary <ScopeField, List <ReferenceDataItem> >
{
{ ScopeField.Environment, new List <ReferenceDataItem>() },
{ ScopeField.Machine, new List <ReferenceDataItem>() },
{ ScopeField.Channel, new List <ReferenceDataItem>() },
};
foreach (var variable in variables)
{
foreach (var variableScope in variable.Scope)
{
switch (variableScope.Key)
{
case ScopeField.Environment:
var usedEnvironments = variableScope.Value;
foreach (var usedEnvironment in usedEnvironments)
{
var environment = variableScopeValues.Environments.Find(e => e.Id == usedEnvironment);
if (environment != null)
{
usedScopeValues[ScopeField.Environment].Add(environment);
}
}
break;
case ScopeField.Machine:
var usedMachines = variableScope.Value;
foreach (var usedMachine in usedMachines)
{
var machine = variableScopeValues.Machines.Find(m => m.Id == usedMachine);
if (machine != null)
{
usedScopeValues[ScopeField.Machine].Add(machine);
}
}
break;
case ScopeField.Channel:
var usedChannels = variableScope.Value;
foreach (var usedChannel in usedChannels)
{
var channel = variableScopeValues.Channels.Find(c => c.Id == usedChannel);
if (channel != null)
{
usedScopeValues[ScopeField.Channel].Add(channel);
}
}
break;
}
}
}
foreach (var step in steps)
{
foreach (var action in step.Actions)
{
foreach (var usedEnvironment in action.Environments)
{
var environment = variableScopeValues.Environments.Find(e => e.Id == usedEnvironment);
if (environment != null && !usedScopeValues[ScopeField.Environment].Exists(env => env.Id == usedEnvironment))
{
usedScopeValues[ScopeField.Environment].Add(environment);
}
}
foreach (var usedChannel in action.Channels)
{
var channel = variableScopeValues.Channels.Find(c => c.Id == usedChannel);
if (channel != null && !usedScopeValues[ScopeField.Channel].Exists(ch => ch.Id == usedChannel))
{
usedScopeValues[ScopeField.Channel].Add(channel);
}
}
}
}
return(usedScopeValues);
}
private FriendlyScopeCollection ToFriendlyScopeCollection(ScopeSpecification variableScope, VariableScopeValues scopeValues)
{
var scopeCollection = new FriendlyScopeCollection();
foreach (var scope in variableScope)
{
switch (scope.Key.ToString())
{
case "Machine":
scopeCollection.Machines = scopeValues.Machines.Where(m => scope.Value.Contains(m.Id)).Select(m => m.Name).ToList();
break;
case "Environment":
scopeCollection.Environments = scopeValues.Environments.Where(e => scope.Value.Contains(e.Id)).Select(e => e.Name).ToList();
break;
case "Action":
scopeCollection.Actions = scopeValues.Actions.Where(a => scope.Value.Contains(a.Id)).Select(a => a.Name).ToList();
break;
case "Role":
scopeCollection.Roles = scopeValues.Roles.Where(r => scope.Value.Contains(r.Id)).Select(r => r.Name).ToList();
break;
case "Channel":
scopeCollection.Channels = scopeValues.Channels.Where(c => scope.Value.Contains(c.Id)).Select(c => c.Name).ToList();
break;
}
}
return(scopeCollection);
}
private List <FriendlyVariable> ToFriendlyVariables(IList <VariableResource> Variables, VariableScopeValues ScopeValues)
{
var list = new List <FriendlyVariable>();
foreach (var variable in Variables)
{
var scope = ToFriendlyScopeCollection(variable.Scope, ScopeValues);
list.Add(new FriendlyVariable()
{
Name = variable.Name,
Value = variable.Name,
IsEditable = variable.IsEditable,
IsSensitive = variable.IsSensitive,
Scope = scope,
Prompt = variable.Prompt
});
}
return(list);
}
