private static ScopeSpecification CreateScopeSpesification(OctoVariable variable, VariableSetResource variableSet) { var scopeSpecifiaciton = new ScopeSpecification(); variable.Scopes.ForEach(scope => { ScopeField scopeName = FindScopeName(scope); List <ReferenceDataItem> referenceDataItems = FindScopeValue(scopeName, variableSet); List <string> scopeValues = referenceDataItems.Join(scope.Values, refDataItem => refDataItem.Name, selectedScope => selectedScope, (item, s) => item.Id) .ToList(); if (!scopeValues.Any()) { throw new CakeException($"({string.Join(",", scope.Values)}) value(s) can not be found on ({scope.Name}) scope."); } var value = new ScopeValue(scopeValues.First(), scopeValues.Skip(1).ToArray()); scopeSpecifiaciton.Add(scopeName, value); }); return(scopeSpecifiaciton); }
public async Task UpdateVariableSet(VariableSet varSet) { var id = varSet.Id; if (varSet.IdType == VariableSet.VariableIdTypes.Library) { id = (await client.Repository.LibraryVariableSets.Get(id)).VariableSetId; } var set = await client.Repository.VariableSets.Get(id); foreach (var variable in varSet.Variables) { var scope = new ScopeSpecification(); if (variable.EnvironmentIds.Any()) { scope.Add(ScopeField.Environment, new ScopeValue(variable.EnvironmentIds)); } if (variable.TargetIds.Any()) { scope.Add(ScopeField.Machine, new ScopeValue(variable.TargetIds)); } if (variable.RoleIds.Any()) { scope.Add(ScopeField.Role, new ScopeValue(variable.RoleIds)); } set.AddOrUpdateVariableValue(variable.Key, variable.Value, scope); } await client.Repository.VariableSets.Modify(set); }
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); }
public async Task UpdateVars(List <SecretVariable> vars, string libraryName, IEnumerable <string> environments, IEnumerable <string> roles, bool apply) { var lib = await _octopusRepository.ValidateLibrary(libraryName).ConfigureAwait(false); var set = await _octopusRepository.VariableSets.Get(lib.VariableSetId).ConfigureAwait(false); var scope = new ScopeSpecification(); foreach (var environment in environments) { var enviro = await _octopusRepository.ValidateEnvironment(environment).ConfigureAwait(false); if (scope.ContainsKey(ScopeField.Environment)) { scope[ScopeField.Environment].Add(enviro.Id); } else { scope.Add(ScopeField.Environment, new ScopeValue(enviro.Id)); } } await _octopusRepository.ValidateRoles(roles).ConfigureAwait(false); scope.Add(ScopeField.Role, new ScopeValue(roles)); foreach (var variable in vars) { set.AddOrUpdateVariableValue(variable.Name, variable.Value, scope, variable.IsSecret); } if (apply) { await _octopusRepository.VariableSets.Modify(set).ConfigureAwait(false); } }
public static ScopeSpecification UpdateWith(this ScopeSpecification resource, IReadOnlyDictionary <VariableScopeType, IEnumerable <ElementReference> > model, IOctopusRepository repository, DeploymentProcessResource deploymentProcess, ProjectResource project) { resource.Clear(); foreach (var kv in model) { resource.Add((ScopeField)kv.Key, new ScopeValue(kv.Value.Select(reference => ResolveId(kv.Key, reference, repository, deploymentProcess, project)))); } return(resource); }
private static ScopeSpecification CreateScope(ScopeSpecification scopeSpec, CopyScopeValue copyAction = null) { var spec = new ScopeSpecification(); foreach (var scope in scopeSpec) { if (scope.Key != ScopeField.Action) spec.Add(scope.Key, new ScopeValue(scope.Value)); else if (copyAction != null) spec.Add(scope.Key, copyAction(scope)); } return spec; }
private VariableResource CreateVariable(string key, VariableSetResource variableSet) { var scope = new ScopeSpecification(); scope.AddRange(VariableFilter.BuildScopeMap(variableSet.ScopeValues, _config.Filter)); var v = new VariableResource { Name = key, Scope = scope }; variableSet.Variables.Add(v); return v; }
private static ScopeSpecification CreateScope(ScopeSpecification scopeSpec, CopyScopeValue copyAction = null) { var spec = new ScopeSpecification(); foreach (var scope in scopeSpec) { if (scope.Key != ScopeField.Action) { spec.Add(scope.Key, new ScopeValue(scope.Value)); } else if (copyAction != null) { spec.Add(scope.Key, copyAction(scope)); } } return(spec); }
public VariableSetResource AddOrUpdateVariableValue(string name, string value, ScopeSpecification scope) { var existing = Variables.FirstOrDefault(x => string.Equals(x.Name, name, StringComparison.OrdinalIgnoreCase) && x.Scope.Equals(scope)); if (existing == null) { var template = new VariableResource { Name = name, Value = value, Scope = scope, }; Variables.Add(template); } else { existing.Name = name; existing.Value = value; existing.Scope = scope; } return this; }
public VariableSetEditor AddOrUpdateVariableValue(string name, string value, ScopeSpecification scope) { Instance.AddOrUpdateVariableValue(name, value, scope); return(this); }
public static Dictionary <VariableScopeType, IEnumerable <ElementReference> > ToModel(this ScopeSpecification resource, DeploymentProcessResource deploymentProcessResource, IOctopusRepository repository) { return(resource.ToDictionary(kv => (VariableScopeType)kv.Key, kv => kv.Value.Select(id => ResolveReference(kv.Key, id, repository, deploymentProcessResource)).ToArray().AsEnumerable())); }
public VariableSetEditor AddOrUpdateVariableValue(string name, string value, ScopeSpecification scope, bool isSensitive, string description) { Instance.AddOrUpdateVariableValue(name, value, scope, isSensitive, description); return(this); }
public static async Task <Dictionary <VariableScopeType, IEnumerable <ElementReference> > > ToModel(this ScopeSpecification resource, DeploymentProcessResource deploymentProcessResource, IOctopusAsyncRepository repository) { var model = new Dictionary <VariableScopeType, IEnumerable <ElementReference> >(); foreach (var kv in resource) { model.Add((VariableScopeType)kv.Key, await Task.WhenAll(kv.Value.Select(id => ResolveReference(kv.Key, id, repository, deploymentProcessResource)))); } return(await Task.FromResult(model)); }
private static void AddVariableToProject(string variableName, string variableValue, ProjectResource project, ScopeSpecification scope) { var variableSet = _repository.VariableSets.Get(project.VariableSetId).Result; variableSet.AddOrUpdateVariableValue(variableName, variableValue, scope); Log.Information($"Adding variable [{variableName}] to project [{project.Name}]"); _repository.VariableSets.Modify(variableSet).Wait(); }
public VariableResource() { Id = Guid.NewGuid().ToString(); Scope = new ScopeSpecification(); }