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;
 }