public DeploymentValidationResult ValidateDeployment(DeployProject project, DeployComponent component, DeployEnvironment environment)
{
var returnValue = new DeploymentValidationResult();
DeployEnvironmentConfiguration environmentConfiguration;
List<DeployStep> deploymentStepList;
if(component.UseConfigurationGroup)
{
environmentConfiguration = environment.TryGetConfigurationItem(component.ConfigurationId);
var configuration = project.GetConfiguration(component.ConfigurationId);
deploymentStepList = configuration.DeploymentStepList;;
}
else
{
environmentConfiguration = environment.TryGetComponentItem(component.Id);
deploymentStepList = component.DeploymentStepList;
}
if(environmentConfiguration != null)
{
foreach(var deploymentStep in deploymentStepList)
{
var taskDefinition = _taskFactory.CreateTaskDefinition(deploymentStep.TaskTypeName, deploymentStep.TaskOptionsJson);
var validationItem = this.ValidateTaskDefinition(taskDefinition, environmentConfiguration);
returnValue.AddResult(deploymentStep, validationItem);
}
}
return returnValue;
}
private void AssertCreatedEnvironment(DeployEnvironment result, DeployProject project, string environmentName, List<DeployEnvironmentConfiguration> environmentComponentList, List<DeployEnvironmentConfiguration> environmentConfigurationList, IProjectRepository sut)
{
Assert.IsNotNull(result);
Assert.IsNotNullOrEmpty(result.Id);
Assert.AreEqual(project.Id, result.ProjectId);
Assert.AreEqual(environmentName, result.EnvironmentName);
AssertHelpers.AssertCreatedBaseDto(result, this.UserName);
environmentComponentList = environmentComponentList ?? new List<DeployEnvironmentConfiguration>();
Assert.AreEqual(environmentComponentList.Count(), result.ComponentList.Count);
foreach(var item in environmentComponentList)
{
var createdItem = result.ComponentList.SingleOrDefault(i=>i.ParentId == item.ParentId);
AssertCreatedEnvironmentConfiguration(item, createdItem, project, result, EnumDeployStepParentType.Component);
}
environmentConfigurationList = environmentConfigurationList ?? new List<DeployEnvironmentConfiguration>();
Assert.AreEqual(environmentConfigurationList.Count(), result.ConfigurationList.Count);
foreach (var item in environmentConfigurationList)
{
var createdItem = result.ConfigurationList.SingleOrDefault(i => i.ParentId == item.ParentId);
AssertCreatedEnvironmentConfiguration(item, createdItem, project, result, EnumDeployStepParentType.Configuration);
}
var dbItem = sut.GetEnvironment(result.Id, result.ProjectId);
AssertEnvironment(result, dbItem);
var dbProject = sut.GetProject(project.Id);
var dbProjectEnvironment = dbProject.EnvironmentList.SingleOrDefault(i => i.Id == result.Id);
Assert.IsNotNull(dbProjectEnvironment);
AssertEnvironment(result, dbProjectEnvironment);
}
public object Post(DeployProject project)
{
if(string.IsNullOrEmpty(project.Id))
{
return _projectManager.CreateProject(project.ProjectName, project.UsesSharedComponentConfiguration);
}
else
{
return _projectManager.UpdateProject(project.Id, project.ProjectName, project.UsesSharedComponentConfiguration);
}
}
public object Get(DeployProject request)
{
if(request != null && !string.IsNullOrEmpty(request.Id))
{
var project = _projectManager.GetProject(request.Id);
return _parameterMasker.Mask(project);
}
else
{
var projectList = _projectManager.GetProjectList();
return _parameterMasker.Mask(projectList);
}
}
public DeployProject Mask(DeployProject project)
{
if(project == null)
{
return null;
}
var newProject = AutoMapper.Mapper.Map(project, new DeployProject());
if(project.EnvironmentList != null)
{
newProject.EnvironmentList = this.Mask(project, project.EnvironmentList).ToList();
}
return newProject;
}
public void CanCreateProject()
{
var repository = new Mock<IProjectRepository>();
IProjectManager sut = new ProjectManager(repository.Object, new Mock<IDeployTaskFactory>().Object);
var project = new DeployProject
{
ProjectName = Guid.NewGuid().ToString(),
Id = Guid.NewGuid().ToString(),
UsesSharedComponentConfiguration = false
};
repository.Setup(i=>i.CreateProject(project.ProjectName, project.UsesSharedComponentConfiguration)).Returns(project);
DeployProject result = sut.CreateProject(project.ProjectName, project.UsesSharedComponentConfiguration);
Assert.AreEqual(project, result);
repository.Verify(i => i.CreateProject(project.ProjectName, project.UsesSharedComponentConfiguration), Times.Once());
}
public IEnumerable<DeployEnvironment> Mask(DeployProject project, IEnumerable<DeployEnvironment> environmentList)
{
if(environmentList == null)
{
return null;
}
if (project == null)
{
throw new ArgumentNullException("Missing project");
}
var newEnvironmentList = new List<DeployEnvironment>();
foreach(var environment in environmentList)
{
var newEnvironment = this.Mask(project, environment);
newEnvironmentList.Add(newEnvironment);
}
return newEnvironmentList;
}
public DeployEnvironment Mask(DeployProject project, DeployEnvironment environment)
{
if(environment == null)
{
return null;
}
if (project == null)
{
throw new ArgumentNullException("Missing project");
}
var newEnvironment = AutoMapper.Mapper.Map(environment, new DeployEnvironment());
if (environment.ConfigurationList != null)
{
newEnvironment.ConfigurationList = this.Mask(project, environment.ConfigurationList).ToList();
}
if(environment.ComponentList != null)
{
newEnvironment.ComponentList = this.Mask(project, environment.ComponentList).ToList();
}
return newEnvironment;
}
private DeployProjectRolePermissions ValidatePermissions(DeployProjectRolePermissions permissions, string projectRoleId, DeployProject project)
{
permissions = permissions ?? new DeployProjectRolePermissions();
permissions.RequestDeployPermissionList = permissions.RequestDeployPermissionList ?? new List<DeployProjectRoleEnvironmentPermission>();
this.ValidateEnvironmentPermissions(permissions.RequestDeployPermissionList, projectRoleId, project);
permissions.ApproveRejectDeployPermissionList = permissions.ApproveRejectDeployPermissionList ?? new List<DeployProjectRoleEnvironmentPermission>();
this.ValidateEnvironmentPermissions(permissions.ApproveRejectDeployPermissionList, projectRoleId, project);
permissions.RunDeploymentPermissionList = permissions.RunDeploymentPermissionList ?? new List<DeployProjectRoleEnvironmentPermission>();
this.ValidateEnvironmentPermissions(permissions.RunDeploymentPermissionList, projectRoleId, project);
permissions.EditEnvironmentPermissionList = permissions.EditEnvironmentPermissionList ?? new List<DeployProjectRoleEnvironmentPermission>();
this.ValidateEnvironmentPermissions(permissions.EditEnvironmentPermissionList, projectRoleId, project);
permissions.EditEnvironmentPermissionsPermissionList = permissions.EditEnvironmentPermissionsPermissionList ?? new List<DeployProjectRoleEnvironmentPermission>();
this.ValidateEnvironmentPermissions(permissions.EditEnvironmentPermissionsPermissionList, projectRoleId, project);
return permissions;
}
private void ValidateEnvironmentPermissions(List<DeployProjectRoleEnvironmentPermission> permissionList, string projectRoleId, DeployProject project)
{
var itemsToDelete = new List<DeployProjectRoleEnvironmentPermission>();
foreach(var item in permissionList)
{
var environment = project.EnvironmentList.FirstOrDefault(i=>i.Id == item.EnvironmentId);
if(environment == null)
{
itemsToDelete.Add(item);
}
else
{
item.EnvironmentName = environment.EnvironmentName;
}
}
foreach(var item in itemsToDelete)
{
permissionList.Remove(item);
}
foreach(var environment in project.EnvironmentList)
{
var item = permissionList.FirstOrDefault(i=>i.EnvironmentId == environment.Id);
if(item == null)
{
item = new DeployProjectRoleEnvironmentPermission
{
EnvironmentId = environment.Id,
EnvironmentName = environment.EnvironmentName,
//ProjectId = project.Id,
//ProjectRoleId = projectRoleId,
Access = EnumPermissionAccess.Grant
};
permissionList.Add(item);
}
}
}
public void SendBuildPublishedNotification(DeployProject project, DeployBuild build)
{
}
private DeployProjectRole ValidateRole(DeployProjectRole role, DeployProject project)
{
role.Permissions = this.ValidatePermissions(role.Permissions, role.Id, project);
role.ProjectName = project.ProjectName;
return role;
}
public void SendBuildPublishedNotification(DeployProject project, DeployBuild build)
{
var emailAddresseList = GetNotificationEmailAddresses(project.Id, i=>i.BuildPublished);
if(emailAddresseList != null && emailAddresseList.Count > 0)
{
var dataObject = new
{
Project = project,
Build = build,
ViewBuildUrl = _urlGenerator.ViewBuildUrl(build.Id)
};
var template = _razorTemplateRepository.GetTemplate("BuildPublishEmail", _notificationResourceViews.BuildPublishEmailView);
_emailQueue.QueueMessage("New Build Published", emailAddresseList, dataObject, template.ViewData);
}
}
private DeployProjectRole CreateEveryoneRole(DeployProject project)
{
var role = new DeployProjectRole
{
Id = "Everyone",
ProjectId = project.Id,
ProjectName = project.ProjectName,
RoleName = "Everyone",
EveryoneRoleIndicator = true
};
role.Permissions = this.ValidatePermissions(role.Permissions, role.Id, project);
role.Permissions.EditComponentConfigurationAccess = EnumPermissionAccess.Grant;
role.Permissions.CreateEnvironmentAccess = EnumPermissionAccess.Grant;
role.Permissions.EditProjectPermissionsAccess = EnumPermissionAccess.Grant;
foreach (var item in role.Permissions.RequestDeployPermissionList)
{
item.Access = EnumPermissionAccess.Grant;
}
foreach(var item in role.Permissions.RunDeploymentPermissionList)
{
item.Access = EnumPermissionAccess.Grant;
}
foreach(var item in role.Permissions.ApproveRejectDeployPermissionList)
{
item.Access = EnumPermissionAccess.Grant;
}
foreach(var item in role.Permissions.EditEnvironmentPermissionList)
{
item.Access = EnumPermissionAccess.Grant;
}
foreach(var item in role.Permissions.EditEnvironmentPermissionsPermissionList)
{
item.Access = EnumPermissionAccess.Grant;
}
return role;
}
public DeployEnvironmentConfiguration Unmask(DeployProject project, DeployEnvironmentConfiguration environmentConfiguration, DeployEnvironment originalEnvironment)
{
if(environmentConfiguration == null)
{
return null;
}
if(project == null)
{
throw new ArgumentNullException("Missing project");
}
var newEnvironmentConfiguration = AutoMapper.Mapper.Map(environmentConfiguration, new DeployEnvironmentConfiguration());
if (string.IsNullOrEmpty(environmentConfiguration.Id))
{
//New item being created, don't need to unmask
return newEnvironmentConfiguration;
}
DeployEnvironmentConfiguration originalEnviromentConfiguration;
switch(environmentConfiguration.ParentType)
{
case EnumDeployStepParentType.Configuration:
originalEnviromentConfiguration = originalEnvironment.ConfigurationList.FirstOrDefault(i => i.ParentType == environmentConfiguration.ParentType && i.ParentId == environmentConfiguration.ParentId);
break;
case EnumDeployStepParentType.Component:
originalEnviromentConfiguration = originalEnvironment.ComponentList.FirstOrDefault(i => i.ParentType == environmentConfiguration.ParentType && i.ParentId == environmentConfiguration.ParentId);
break;
default:
throw new UnknownEnumValueException(environmentConfiguration.ParentType);
}
if(originalEnviromentConfiguration != null)
{
List<DeployStep> deploymentStepList = new List<DeployStep>();
switch (newEnvironmentConfiguration.ParentType)
{
case EnumDeployStepParentType.Component:
var component = project.ComponentList.FirstOrDefault(i => i.Id == newEnvironmentConfiguration.ParentId);
if (component != null)
{
deploymentStepList = component.DeploymentStepList;
}
break;
case EnumDeployStepParentType.Configuration:
var configuration = project.ConfigurationList.FirstOrDefault(i => i.Id == newEnvironmentConfiguration.ParentId);
if (configuration != null)
{
deploymentStepList = configuration.DeploymentStepList;
}
break;
default:
throw new UnknownEnumValueException(newEnvironmentConfiguration.ParentType);
}
var definition = _deploymentValidator.GetComponentConfigurationDefinition(deploymentStepList);
if (definition.EnvironmentTaskParameterList != null)
{
foreach (var parameterDefinition in definition.EnvironmentTaskParameterList.Where(i => i.Sensitive))
{
if (newEnvironmentConfiguration.ConfigurationValueList.ContainsKey(parameterDefinition.FieldName)
&& originalEnviromentConfiguration.ConfigurationValueList.ContainsKey(parameterDefinition.FieldName))
{
if(newEnvironmentConfiguration.ConfigurationValueList[parameterDefinition.FieldName] == this.MaskValue)
{
newEnvironmentConfiguration.ConfigurationValueList[parameterDefinition.FieldName] = originalEnviromentConfiguration.ConfigurationValueList[parameterDefinition.FieldName];
}
}
}
}
if (definition.MachineTaskParameterList != null && newEnvironmentConfiguration.MachineList != null && originalEnviromentConfiguration.MachineList != null)
{
foreach (var parameterDefinition in definition.MachineTaskParameterList.Where(i => i.Sensitive))
{
foreach(var newMachineConfiguration in newEnvironmentConfiguration.MachineList)
{
var originalMachineConfiguration = originalEnviromentConfiguration.MachineList.FirstOrDefault(i=>i.Id == newMachineConfiguration.Id);
if(originalMachineConfiguration != null)
{
if(newMachineConfiguration.ConfigurationValueList.ContainsKey(parameterDefinition.FieldName)
&& originalMachineConfiguration.ConfigurationValueList.ContainsKey(parameterDefinition.FieldName))
{
if (newMachineConfiguration.ConfigurationValueList[parameterDefinition.FieldName] == this.MaskValue)
{
newMachineConfiguration.ConfigurationValueList[parameterDefinition.FieldName] = originalMachineConfiguration.ConfigurationValueList[parameterDefinition.FieldName];
}
}
}
}
}
}
}
return newEnvironmentConfiguration;
}
private void AssertCreatedEnvironmentConfiguration(DeployEnvironmentConfiguration sourceItem, DeployEnvironmentConfiguration createdItem, DeployProject project, DeployEnvironment environment, EnumDeployStepParentType parentType)
{
Assert.IsNotNull(createdItem);
AssertHelpers.AssertCreatedBaseDto(createdItem, this.UserName);
Assert.AreEqual(project.Id, createdItem.ProjectId);
Assert.AreEqual(sourceItem.ParentId, createdItem.ParentId);
Assert.AreEqual(parentType, createdItem.ParentType);
Assert.AreEqual(sourceItem.DeployCredentialsId, createdItem.DeployCredentialsId);
AssertHelpers.AssertDictionary(sourceItem.ConfigurationValueList, createdItem.ConfigurationValueList);
Assert.AreEqual(sourceItem.MachineList.Count, createdItem.MachineList.Count);
foreach(var sourceMachine in sourceItem.MachineList)
{
var createdMachine = createdItem.MachineList.SingleOrDefault(i=>i.MachineName == sourceMachine.MachineName);
Assert.IsNotNull(createdMachine);
AssertHelpers.AssertCreatedBaseDto(createdMachine, this.UserName);
Assert.AreEqual(project.Id, createdMachine.ProjectId);
Assert.AreEqual(environment.Id, createdMachine.EnvironmentId);
Assert.AreEqual(environment.EnvironmentName, createdMachine.EnvironmentName);
Assert.AreEqual(sourceItem.Id, createdMachine.ParentId);
AssertHelpers.AssertDictionary(sourceMachine.ConfigurationValueList, createdMachine.ConfigurationValueList);
}
}
private void SetPermission(DeployProject project, DeployEnvironment environment, List<DeployProjectRoleEnvironmentPermission> list, EnumPermissionAccess access)
{
foreach(var x in project.EnvironmentList)
{
var item = list.FirstOrDefault(i=>i.EnvironmentId == x.Id);
if(item == null)
{
item = new DeployProjectRoleEnvironmentPermission
{
//Id = this.Fixture.Create<string>(),
//ProjectId = project.Id,
EnvironmentId = x.Id,
EnvironmentName = x.CreatedByUserName
};
list.Add(item);
}
}
list.First(i=>i.EnvironmentId == environment.Id).Access = access;
}
public IEnumerable<DeployEnvironmentConfiguration> Mask(DeployProject project, IEnumerable<DeployEnvironmentConfiguration> environmentConfigurationList)
{
if (environmentConfigurationList == null)
{
return null;
}
if (project == null)
{
throw new ArgumentNullException("Missing project");
}
var newConfigurationList = new List<DeployEnvironmentConfiguration>();
foreach(var configuration in environmentConfigurationList)
{
var newConfiguration = this.Mask(project, configuration);
newConfigurationList.Add(newConfiguration);
}
return newConfigurationList;
}
private void LoadProjectChildren(DeployProject project)
{
project.BranchList = GetBranchList(project.Id).ToList();
project.ConfigurationList = GetConfigurationList(project.Id);
project.ComponentList = GetComponentList(project.Id);
project.EnvironmentList = GetEnvironmentList(project.Id);
}
public void CanRetrieveProjectByID()
{
var repository = new Mock<IProjectRepository>();
var project = new DeployProject
{
ProjectName = Guid.NewGuid().ToString(),
Id = Guid.NewGuid().ToString()
};
repository.Setup(i=>i.GetProject(project.Id)).Returns(project);
IProjectManager sut = new ProjectManager(repository.Object, new Mock<IDeployTaskFactory>().Object);
DeployProject result = sut.GetProject(project.Id);
Assert.AreEqual(project, result);
repository.Verify(i=>i.GetProject(project.Id), Times.Once());
}
public void CanUpdateDeploymentStep()
{
string projectId = Guid.NewGuid().ToString();
string componentId = Guid.NewGuid().ToString();
string deploymentStepId = Guid.NewGuid().ToString();
string stepName = Guid.NewGuid().ToString();
string taskTypeName = typeof(TestTaskType).ToString();
string taskOptionsJson = Guid.NewGuid().ToString();
var projectRepository = new Mock<IProjectRepository>();
var project = new DeployProject
{
Id = projectId,
ComponentList = new List<DeployComponent>(),
UsesSharedComponentConfiguration = false
};
projectRepository.Setup(i=>i.GetProject(projectId)).Returns(project);
projectRepository.Setup(i => i.UpdateComponentDeploymentStep(deploymentStepId, project.Id, componentId, stepName, taskTypeName, taskOptionsJson, null, null))
.Returns(new DeployStep
{
Id = deploymentStepId,
StepName = stepName,
TaskTypeName = taskTypeName,
TaskOptionsJson = Guid.NewGuid().ToString(),
ParentId = componentId,
ProjectId = projectId,
SharedDeploymentStepId = Guid.NewGuid().ToString(),
});
IProjectManager sut = new ProjectManager(projectRepository.Object, new Mock<IDeployTaskFactory>().Object);
var result = sut.UpdateComponentDeploymentStep(deploymentStepId, projectId, componentId, stepName, taskTypeName, taskOptionsJson);
Assert.IsNotNull(result);
Assert.AreEqual(stepName, result.StepName);
projectRepository.Verify(i => i.UpdateComponentDeploymentStep(deploymentStepId, project.Id, componentId, stepName, taskTypeName, taskOptionsJson,null, null), Times.Once());
}
public void MissingTaskOptions_CreatesTaskOptions()
{
//var project = new DeployProject
//{
// ProjectName = Guid.NewGuid().ToString(),
// Id = Guid.NewGuid().ToString(),
// UsesSharedComponentConfiguration = false
//};
//string componentId = Guid.NewGuid().ToString();
//string stepName = Guid.NewGuid().ToString();
//string taskTypeName = typeof(TestTaskType).ToString();
//string taskOptionsJson = null;
//var projectRepository = new Mock<IProjectRepository>();
//projectRepository.Setup(i => i.GetProject(project.Id)).Returns(project);
//var deployTaskFactory = new Mock<IDeployTaskFactory>();
//deployTaskFactory.Setup(i=>i.CreateTaskDefinition(taskTypeName, It.IsAny<string>())).Returns(new TestTaskType() { DeployTaskOptions = new object() });
//IProjectManager sut = new ProjectManager(projectRepository.Object, deployTaskFactory.Object);
//var result = sut.CreateComponentDeploymentStep(project.Id, componentId, stepName, taskTypeName, taskOptionsJson);
//Assert.IsNotNull(result);
//Assert.AreEqual(stepName, result.StepName);
//projectRepository.Verify(i => i.CreateComponentDeploymentStep(project.Id, componentId, stepName, taskTypeName, It.IsAny<string>(), null), Times.Once());
string projectId = Guid.NewGuid().ToString();
string componentId = Guid.NewGuid().ToString();
string stepName = Guid.NewGuid().ToString();
string taskTypeName = typeof(TestTaskType).ToString();
string taskOptionsJson = null;
var projectRepository = new Mock<IProjectRepository>();
var project = new DeployProject
{
Id = projectId,
ComponentList = new List<DeployComponent>(),
UsesSharedComponentConfiguration = false
};
projectRepository.Setup(i => i.GetProject(projectId))
.Returns(project);
projectRepository.Setup(i => i.CreateComponentDeploymentStep(project.Id, componentId, stepName, taskTypeName, It.IsAny<string>(), null))
.Returns(new DeployStep
{
Id = Guid.NewGuid().ToString(),
StepName = stepName,
TaskTypeName = taskTypeName,
TaskOptionsJson = taskOptionsJson,
ProjectId = projectId,
ParentId = componentId,
SharedDeploymentStepId = Guid.NewGuid().ToString()
});
var deployTaskFactory = new Mock<IDeployTaskFactory>();
deployTaskFactory.Setup(i=>i.CreateTaskDefinition(taskTypeName, It.IsAny<string>())).Returns(new TestTaskType() { DeployTaskOptions = new object() });
IProjectManager sut = new ProjectManager(projectRepository.Object, deployTaskFactory.Object);
var result = sut.CreateComponentDeploymentStep(projectId, componentId, stepName, taskTypeName, taskOptionsJson);
Assert.IsNotNull(result);
Assert.AreEqual(stepName, result.StepName);
projectRepository.Verify(i => i.CreateComponentDeploymentStep(project.Id, componentId, stepName, taskTypeName, It.IsAny<string>(), null), Times.Once());
}
public void BadId_ThrowsError()
{
var repository = new Mock<IProjectRepository>();
var project = new DeployProject
{
ProjectName = Guid.NewGuid().ToString(),
Id = Guid.NewGuid().ToString()
};
repository.Setup(i => i.GetProject(project.Id)).Returns((DeployProject)null);
IProjectManager sut = new ProjectManager(repository.Object, new Mock<IDeployTaskFactory>().Object);
Assert.Throws<KeyNotFoundException>(delegate { sut.GetProject(project.Id); });
repository.Verify(i => i.GetProject(It.IsAny<string>()), Times.Once());
}
public DeployProjectRole AddRoleAssignment(DeployProject project, DeployEnvironment environment,
EnumPermissionAccess createEnvironmentAccess=EnumPermissionAccess.None,
EnumPermissionAccess editComponentConfigurationAccess=EnumPermissionAccess.None,
EnumPermissionAccess editProjectPermissionsAccess=EnumPermissionAccess.None,
EnumPermissionAccess approveRejectDeployAccess=EnumPermissionAccess.None,
EnumPermissionAccess requestDeploymentAccess=EnumPermissionAccess.None,
EnumPermissionAccess runDeploymentmentAccess=EnumPermissionAccess.None,
EnumPermissionAccess editEnvironmentAccess=EnumPermissionAccess.None,
EnumPermissionAccess editEnvironmentPermissionsAccess = EnumPermissionAccess.None)
{
string roleId = this.Fixture.Create<string>();
var role = new DeployProjectRole
{
Id = roleId,
ProjectId = project.Id,
RoleName = this.Fixture.Create<string>("RoleName"),
Assignments = new DeployProjectRoleAssignments
{
UserNameList = new List<string> { this.UserName }
},
EveryoneRoleIndicator = false
};
role.Permissions.EditComponentConfigurationAccess = editComponentConfigurationAccess;
role.Permissions.CreateEnvironmentAccess = createEnvironmentAccess;
role.Permissions.EditProjectPermissionsAccess = editProjectPermissionsAccess;
this.SetPermission(project, environment, role.Permissions.ApproveRejectDeployPermissionList, approveRejectDeployAccess);
this.SetPermission(project, environment, role.Permissions.RequestDeployPermissionList, requestDeploymentAccess);
this.SetPermission(project, environment, role.Permissions.RunDeploymentPermissionList, runDeploymentmentAccess);
this.SetPermission(project, environment, role.Permissions.EditEnvironmentPermissionList, editEnvironmentAccess);
this.SetPermission(project, environment, role.Permissions.EditEnvironmentPermissionsPermissionList, editEnvironmentPermissionsAccess);
this.DeployProjectRoleList.Add(role);
return role;
}
public void Delete(DeployProject project)
{
_projectManager.DeleteProject(project.Id);
}
public DeployProject CreateProject(string projectName, bool usesSharedComponentConfiguration)
{
if(string.IsNullOrEmpty(projectName))
{
throw new ArgumentNullException("Missing project name");
}
var project = new DeployProject
{
Id = Guid.NewGuid().ToString(),
ProjectName = projectName,
UsesSharedComponentConfiguration = usesSharedComponentConfiguration,
CreatedByUserName = _userIdentity.UserName,
CreatedDateTimeUtc = DateTime.UtcNow,
UpdatedByUserName = _userIdentity.UserName,
UpdatedDateTimeUtc = DateTime.UtcNow
};
using(var db = _sqlConnectionInfo.GetDB())
{
var sql = PetaPoco.Sql.Builder
.Append("INSERT INTO DeployProject (ID, ProjectName, UsesSharedComponentConfiguration, CreatedByUserName, CreatedDateTimeUtc, UpdatedByUserName, UpdatedDateTimeUtc)")
.Append("VALUES (@Id, @ProjectName, @UsesSharedComponentConfiguration, @CreatedByUserName, @CreatedDateTimeUtc, @UpdatedByUserName, @UpdatedDateTimeUtc)", project);
db.Execute(sql);
}
return project;
}
public DeployEnvironmentConfiguration Mask(DeployProject project, DeployEnvironmentConfiguration environmentConfiguration)
{
if(environmentConfiguration == null)
{
return null;
}
if (project == null)
{
throw new ArgumentNullException("Missing project");
}
var newEnvironmentConfiguration = AutoMapper.Mapper.Map(environmentConfiguration, new DeployEnvironmentConfiguration());
if (newEnvironmentConfiguration.ConfigurationValueList != null && newEnvironmentConfiguration.ConfigurationValueList.Any())
{
List<DeployStep> deploymentStepList = new List<DeployStep>();
switch (newEnvironmentConfiguration.ParentType)
{
case EnumDeployStepParentType.Component:
var component = project.ComponentList.FirstOrDefault(i => i.Id == newEnvironmentConfiguration.ParentId);
if(component != null)
{
deploymentStepList = component.DeploymentStepList;
}
break;
case EnumDeployStepParentType.Configuration:
var configuration = project.ConfigurationList.FirstOrDefault(i => i.Id == newEnvironmentConfiguration.ParentId);
if(configuration != null)
{
deploymentStepList = configuration.DeploymentStepList;
}
break;
}
var definition = _deploymentValidator.GetComponentConfigurationDefinition(deploymentStepList);
if(definition.EnvironmentTaskParameterList != null)
{
foreach(var parameterDefinition in definition.EnvironmentTaskParameterList.Where(i=>i.Sensitive))
{
if (newEnvironmentConfiguration.ConfigurationValueList.ContainsKey(parameterDefinition.FieldName))
{
newEnvironmentConfiguration.ConfigurationValueList[parameterDefinition.FieldName] = this.MaskValue;
}
}
}
if(definition.MachineTaskParameterList != null && newEnvironmentConfiguration.MachineList != null)
{
foreach (var parameterDefinition in definition.MachineTaskParameterList.Where(i => i.Sensitive))
{
foreach(var newMachineConfiguration in newEnvironmentConfiguration.MachineList)
{
if (newMachineConfiguration.ConfigurationValueList.ContainsKey(parameterDefinition.FieldName))
{
newMachineConfiguration.ConfigurationValueList[parameterDefinition.FieldName] = this.MaskValue;
}
}
}
}
}
return newEnvironmentConfiguration;
}
