public async Task InactivateProjectEnvironment(Guid organizationId, Guid projectId, Guid environmentId)
{
string loggedUserId = _identityService.GetUserId();
DomainModels.User user = await _userRepository.GetUser(loggedUserId);
DomainModels.Organization organization = user.FindOrganizationById(organizationId);
if (organization == null)
{
await _domainManagerService.AddNotFound($"The organzation with id {organizationId} does not exists.");
return;
}
DomainModels.Project project = user.FindProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return;
}
DomainModels.PipelineRole role = user.GetRoleInProject(projectId);
if (role != DomainModels.PipelineRole.ProjectAdmin)
{
await _domainManagerService.AddForbidden($"You are not authorized to delete environments in this project.");
return;
}
if (project.Status != DomainModels.EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The project with id {projectId} must be in status Active to inactivate a project environment.");
return;
}
DomainModels.ProjectEnvironment environment = project.GetEnvironmentById(environmentId);
if (environment == null)
{
await _domainManagerService.AddNotFound($"The environment with id {environmentId} does not exists.");
return;
}
;
if (environment.Type == DomainModels.EnvironmentType.Fact)
{
await _domainManagerService.AddConflict($"The environment fact cannot be inactivated.");
return;
}
;
if (environment.Status != DomainModels.EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The environment {environment.Name} must be in status Active to be inactivated.");
return;
}
user.InactivateProjectEnvironment(organizationId, projectId, environmentId);
_userRepository.Update(user);
await _userRepository.SaveChanges();
var projectServices = project.GetServicesWithReleaseStages();
foreach (var projectService in projectServices)
{
var @event = new ProjectEnvironmentInactivatedEvent(_correlationId)
{
OrganizationId = organization.OrganizationId,
OrganizationName = organization.Name,
ProjectId = project.ProjectId,
ProjectExternalId = project.ProjectExternalId,
ProjectExternalEndpointId = project.ProjectExternalEndpointId,
ProjectVSTSFakeName = project.ProjectVSTSFakeName,
ProjectName = project.Name,
ServiceName = projectService.Name,
CMSType = project.OrganizationCMS.Type,
CMSAccountId = _dataProtectorService.Unprotect(project.OrganizationCMS.AccountId),
CMSAccountName = _dataProtectorService.Unprotect(project.OrganizationCMS.AccountName),
CMSAccessId = _dataProtectorService.Unprotect(project.OrganizationCMS.AccessId),
CMSAccessSecret = _dataProtectorService.Unprotect(project.OrganizationCMS.AccessSecret),
CMSAccessToken = _dataProtectorService.Unprotect(project.OrganizationCMS.AccessToken),
EnvironmentName = environment.Name,
ReleseStageId = projectService.ReleaseStageId.Value
};
//Cloud Provider Data
@event.CPSType = project.OrganizationCPS.Type;
@event.CPSAccessId = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessId);
@event.CPSAccessName = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessName);
@event.CPSAccessSecret = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessSecret);
@event.CPSAccessRegion = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessRegion);
@event.CPSAccessAppId = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessAppId);
@event.CPSAccessAppSecret = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessAppSecret);
@event.CPSAccessDirectory = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessDirectory);
await _eventBusService.Publish(queueName : "ProjectEnvironmentInactivatedEvent", @event : @event);
}
}
public async Task SortProjectEnvironments(Guid organizationId, Guid projectId, ProjectEnvironmentSortPostRp resource)
{
string loggedUserId = _identityService.GetUserId();
DomainModels.User user = await _userRepository.GetUser(loggedUserId);
DomainModels.Organization organization = user.FindOrganizationById(organizationId);
if (organization == null)
{
await _domainManagerService.AddNotFound($"The organzation with id {organizationId} does not exists.");
return;
}
DomainModels.Project project = user.FindProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return;
}
DomainModels.PipelineRole role = user.GetRoleInProject(projectId);
if (role != DomainModels.PipelineRole.ProjectAdmin)
{
await _domainManagerService.AddForbidden($"You are not authorized to sort environments in this project.");
return;
}
if (project.Status != DomainModels.EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The project with id {projectId} must be in status Active to sort de environments.");
return;
}
var developmentEnvironment = project.GetDevelopmentEnvironment();
var productionEnvironment = project.GetProductionEnvironment();
foreach (var item in resource.Items)
{
var environment = project.GetEnvironmentById(item.EnvironmentId);
if (environment == null)
{
await _domainManagerService.AddNotFound($"The environment with id {item.EnvironmentId}) does not exists.");
return;
}
if (environment.Type == EnvironmentType.Root || environment.Type == EnvironmentType.Fact)
{
await _domainManagerService.AddConflict($"The environment {environment.Name} ({environment.ProjectEnvironmentId}) is not sortable.");
return;
}
if (!(developmentEnvironment.Rank < item.Rank && item.Rank < productionEnvironment.Rank))
{
await _domainManagerService.AddConflict($"The rank of the environment {environment.Name} ({environment.ProjectEnvironmentId}) must be between {developmentEnvironment.Rank + 1} and {productionEnvironment.Rank - 1}.");
return;
}
environment.Rank = item.Rank;
}
var groupped = project.Environments.GroupBy(x => x.Rank);
if (groupped.Count() != project.Environments.Count)
{
await _domainManagerService.AddConflict($"The rank of the environments must be sorted sequentially between {developmentEnvironment.Rank + 1} and {productionEnvironment.Rank - 1}.");
return;
}
_userRepository.Update(user);
await _userRepository.SaveChanges();
var projectServices = project.GetServicesWithReleaseStages();
//send events
foreach (var projectService in projectServices)
{
var @event = new ProjectEnvironmentCreatedEvent(_correlationId)
{
OrganizationId = organization.OrganizationId,
OrganizationName = organization.Name,
ProjectId = project.ProjectId,
ProjectExternalId = project.ProjectExternalId,
ProjectExternalEndpointId = project.ProjectExternalEndpointId,
ProjectVSTSFakeName = project.ProjectVSTSFakeName,
ProjectName = project.Name,
CMSType = project.OrganizationCMS.Type,
CMSAccountId = _dataProtectorService.Unprotect(project.OrganizationCMS.AccountId),
CMSAccountName = _dataProtectorService.Unprotect(project.OrganizationCMS.AccountName),
CMSAccessId = _dataProtectorService.Unprotect(project.OrganizationCMS.AccessId),
CMSAccessSecret = _dataProtectorService.Unprotect(project.OrganizationCMS.AccessSecret),
CMSAccessToken = _dataProtectorService.Unprotect(project.OrganizationCMS.AccessToken),
ReleseStageId = projectService.ReleaseStageId.Value,
ServiceName = projectService.Name,
ServiceLastBuildSuccessVersionId = projectService.LastBuildSuccessVersionId,
ServiceLastBuildSuccessVersionName = projectService.LastBuildSuccessVersionName
};
@event.Environments = new List <ProjectEnvironmentItemCreatedEvent>();
foreach (var item in projectService.Environments)
{
var parentEnvironment = project.GetEnvironments().First(x => x.ProjectEnvironmentId == item.ProjectEnvironmentId);
var serviceEnvironment = new ProjectEnvironmentItemCreatedEvent();
serviceEnvironment.Id = item.ProjectEnvironmentId;
serviceEnvironment.Name = parentEnvironment.Name;
serviceEnvironment.RequiredApproval = parentEnvironment.RequiresApproval;
serviceEnvironment.Variables = new List <ProjectEnvironmentItemVariableCreatedEvent>();
serviceEnvironment.Rank = parentEnvironment.Rank;
serviceEnvironment.LastSuccessVersionId = item.LastSuccessVersionId;
serviceEnvironment.LastSuccessVersionName = item.LastSuccessVersionName;
if (parentEnvironment.Variables != null)
{
foreach (var variable in parentEnvironment.Variables)
{
serviceEnvironment.Variables.Add(new ProjectEnvironmentItemVariableCreatedEvent()
{
Name = variable.Name,
Value = variable.Value
});
}
}
if (item.Variables != null)
{
foreach (var variable in item.Variables)
{
serviceEnvironment.Variables.Add(new ProjectEnvironmentItemVariableCreatedEvent()
{
Name = variable.Name,
Value = variable.Value
});
}
}
@event.Environments.Add(serviceEnvironment);
}
//Cloud Provider Data
@event.CPSType = project.OrganizationCPS.Type;
@event.CPSAccessId = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessId);
@event.CPSAccessName = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessName);
@event.CPSAccessSecret = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessSecret);
@event.CPSAccessRegion = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessRegion);
await _eventBusService.Publish(queueName : "ProjectEnvironmentCreatedEvent", @event : @event);
}
}
public async Task CreateProjectEnvironment(Guid organizationId, Guid projectId, ProjectEnvironmentPostRp resource)
{
string loggedUserId = _identityService.GetUserId();
DomainModels.User user = await _userRepository.GetUser(loggedUserId);
DomainModels.Organization organization = user.FindOrganizationById(organizationId);
if (organization == null)
{
await _domainManagerService.AddNotFound($"The organzation with id {organizationId} does not exists.");
return;
}
DomainModels.Project project = user.FindProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return;
}
DomainModels.PipelineRole role = user.GetRoleInProject(projectId);
if (role != DomainModels.PipelineRole.ProjectAdmin)
{
await _domainManagerService.AddForbidden($"You are not authorized to create environments in this project.");
return;
}
if (project.Status != DomainModels.EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The project with id {projectId} must be in status Active to add a new feature.");
return;
}
var activeServices = project.GetServicesWithReleaseStages();
if (!activeServices.Any())
{
await _domainManagerService.AddConflict($"At least one pipe must be configured in the project.");
return;
}
DomainModels.ProjectEnvironment existingEnvironment = project.GetEnvironmentByName(resource.Name);
if (existingEnvironment != null)
{
await _domainManagerService.AddConflict($"The environment name {resource.Name} has already been taken.");
return;
}
DomainModels.ProjectEnvironment newEnvironment = user.CreateProjectEnvironment(organizationId, projectId, resource.Name, resource.Description, resource.RequiresApproval, resource.AutoProvision);
_userRepository.Update(user);
await _userRepository.SaveChanges();
await _domainManagerService.AddResult("EnvironmentId", newEnvironment.ProjectEnvironmentId);
}
public async Task CreateProjectEnvironmentVariables(Guid organizationId, Guid projectId, Guid environmentId, ProjectEnvironmentVariablePostRp resource)
{
string loggedUserId = _identityService.GetUserId();
DomainModels.User user = await _userRepository.GetUser(loggedUserId);
DomainModels.Organization organization = user.FindOrganizationById(organizationId);
if (organization == null)
{
await _domainManagerService.AddNotFound($"The organzation with id {organizationId} does not exists.");
return;
}
DomainModels.Project project = user.FindProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return;
}
DomainModels.PipelineRole role = user.GetRoleInProject(projectId);
if (role != DomainModels.PipelineRole.ProjectAdmin)
{
await _domainManagerService.AddForbidden($"You are not authorized to create environments variables in this project.");
return;
}
if (project.Status != DomainModels.EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The project with id {projectId} must be in status Active to add a new feature.");
return;
}
DomainModels.ProjectEnvironment environment = project.GetEnvironmentById(environmentId);
if (environment == null)
{
await _domainManagerService.AddNotFound($"The environment with id {environmentId} does not exists.");
return;
}
bool autoProvision = false;
if (environment.Type == DomainModels.EnvironmentType.Root)
{
foreach (var resourceVariable in resource.Items)
{
if (string.IsNullOrEmpty(resourceVariable.Name) || string.IsNullOrEmpty(resourceVariable.Value))
{
await _domainManagerService.AddConflict($"The environment variable name/value is mandatory.");
return;
}
var variable = environment.GetVariableByName(resourceVariable.Name);
if (variable != null)
{
environment.SetVariable(resourceVariable.Name, resourceVariable.Value);
}
else
{
environment.AddVariable(resourceVariable.Name, resourceVariable.Value);
}
}
}
else
{
DomainModels.ProjectEnvironment rootEnvironment = project.GetRootEnvironment();
foreach (var variable in rootEnvironment.Variables)
{
var resourceVariable = resource.Items.FirstOrDefault(x => x.Name.Equals(variable.Name, StringComparison.InvariantCultureIgnoreCase));
if (resourceVariable == null)
{
await _domainManagerService.AddConflict($"The environment variable {variable.Name} is mandatory.");
return;
}
if (string.IsNullOrEmpty(resourceVariable.Value))
{
await _domainManagerService.AddConflict($"The environment variable value {variable.Name} is mandatory.");
return;
}
var existingVariable = environment.GetVariableByName(resourceVariable.Name);
if (existingVariable != null)
{
environment.SetVariable(resourceVariable.Name, resourceVariable.Value);
}
else
{
environment.AddVariable(resourceVariable.Name, resourceVariable.Value);
}
}
if (environment.Status == DomainModels.EntityStatus.Preparing)
{
autoProvision = environment.AutoProvision;
}
environment.Activate();
}
var projectServices = project.GetServicesWithReleaseStages();
//replicate service environments
foreach (var projectService in projectServices)
{
var rootVariables = projectService.GetRootEnvironmentVariables();
projectService.AddEnvironment(environment.ProjectEnvironmentId, rootVariables);
}
_userRepository.Update(user);
await _userRepository.SaveChanges();
//send events
foreach (var projectService in projectServices)
{
var @event = new ProjectEnvironmentCreatedEvent(_correlationId)
{
OrganizationId = organization.OrganizationId,
OrganizationName = organization.Name,
ProjectId = project.ProjectId,
ProjectExternalId = project.ProjectExternalId,
ProjectExternalEndpointId = project.ProjectExternalEndpointId,
ProjectVSTSFakeName = project.ProjectVSTSFakeName,
ProjectName = project.Name,
CMSType = project.OrganizationCMS.Type,
CMSAccountId = _dataProtectorService.Unprotect(project.OrganizationCMS.AccountId),
CMSAccountName = _dataProtectorService.Unprotect(project.OrganizationCMS.AccountName),
CMSAccessId = _dataProtectorService.Unprotect(project.OrganizationCMS.AccessId),
CMSAccessSecret = _dataProtectorService.Unprotect(project.OrganizationCMS.AccessSecret),
CMSAccessToken = _dataProtectorService.Unprotect(project.OrganizationCMS.AccessToken),
EnvironmentId = environment.ProjectEnvironmentId,
EnvironmentName = environment.Name,
EnvironmentRank = environment.Rank,
EnvironmentAutoProvision = autoProvision,
ReleseStageId = projectService.ReleaseStageId.Value,
ServiceName = projectService.Name,
ServiceLastBuildSuccessVersionId = projectService.LastBuildSuccessVersionId,
ServiceLastBuildSuccessVersionName = projectService.LastBuildSuccessVersionName
};
@event.Environments = new List <ProjectEnvironmentItemCreatedEvent>();
foreach (var item in projectService.Environments)
{
var parentEnvironment = project.GetEnvironments().First(x => x.ProjectEnvironmentId == item.ProjectEnvironmentId);
var serviceEnvironment = new ProjectEnvironmentItemCreatedEvent();
serviceEnvironment.Id = item.ProjectEnvironmentId;
serviceEnvironment.Name = parentEnvironment.Name;
serviceEnvironment.RequiredApproval = parentEnvironment.RequiresApproval;
serviceEnvironment.Variables = new List <ProjectEnvironmentItemVariableCreatedEvent>();
serviceEnvironment.Rank = parentEnvironment.Rank;
serviceEnvironment.LastSuccessVersionId = item.LastSuccessVersionId;
serviceEnvironment.LastSuccessVersionName = item.LastSuccessVersionName;
if (parentEnvironment.Variables != null)
{
foreach (var variable in parentEnvironment.Variables)
{
serviceEnvironment.Variables.Add(new ProjectEnvironmentItemVariableCreatedEvent()
{
Name = variable.Name,
Value = variable.Value
});
}
}
if (item.Variables != null)
{
foreach (var variable in item.Variables)
{
serviceEnvironment.Variables.Add(new ProjectEnvironmentItemVariableCreatedEvent()
{
Name = variable.Name,
Value = variable.Value
});
}
}
@event.Environments.Add(serviceEnvironment);
}
//Cloud Provider Data
@event.CPSType = project.OrganizationCPS.Type;
@event.CPSAccessId = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessId);
@event.CPSAccessName = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessName);
@event.CPSAccessSecret = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessSecret);
@event.CPSAccessRegion = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessRegion);
await _eventBusService.Publish(queueName : "ProjectEnvironmentCreatedEvent", @event : @event);
}
}
public async Task CreateProjectFeature(Guid organizationId, Guid projectId, ProjectFeaturePostRp resource)
{
string loggedUserId = _identityService.GetUserId();
DomainModels.User user = await _userRepository.GetUser(loggedUserId);
DomainModels.Organization organization = user.FindOrganizationById(organizationId);
if (organization == null)
{
await _domainManagerService.AddNotFound($"The organzation with id {organizationId} does not exists.");
return;
}
DomainModels.Project project = user.FindProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return;
}
DomainModels.PipelineRole role = user.GetRoleInProject(projectId);
if (role != DomainModels.PipelineRole.ProjectAdmin)
{
await _domainManagerService.AddForbidden($"You are not authorized to create features in this project.");
return;
}
if (project.Status != DomainModels.EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The project with id {projectId} must be in status Active to add a new feature.");
return;
}
if (resource.Services.Length == 0)
{
await _domainManagerService.AddConflict($"At least one pipe must be included in the feature.");
return;
}
var preparingServices = project.GetPreparingServices();
if (preparingServices.Any())
{
await _domainManagerService.AddConflict($"The project with id {projectId} has pipes in status Preparing. All services must be in status Active to create a new feature");
return;
}
DomainModels.ProjectFeature existingFeature = project.GetFeatureByName(resource.Name);
if (existingFeature != null)
{
await _domainManagerService.AddConflict($"The feature name {resource.Name} has already been taken.");
return;
}
DomainModels.ProjectFeature newFeature = user.CreateProjectFeature(organizationId, projectId, resource.Name, resource.Description);
//services asociated (TODO: services on demand)
List <ProjectFeatureServiceCreatedEvent> @events = new List <ProjectFeatureServiceCreatedEvent>();
foreach (var item in resource.Services)
{
DomainModels.ProjectService projectService = project.GetServiceById(item);
if (projectService == null)
{
await _domainManagerService.AddConflict($"The pipe id {item} does not exists.");
return;
}
var variables = projectService.Environments.First(x => x.ProjectEnvironment.Type == EnvironmentType.Root).Variables;
newFeature.AddService(item, variables);
var serviceCredential = this._cloudCredentialService.ProjectServiceCredentialResolver(project, projectService);
@events.Add(new ProjectFeatureServiceCreatedEvent(_correlationId)
{
ServiceId = item,
ServiceExternalId = projectService.ProjectServiceExternalId,
ServiceExternalUrl = projectService.ProjectServiceExternalUrl,
ServiceName = projectService.Name,
InternalServiceName = projectService.InternalName,
ServiceTemplateUrl = serviceCredential.BranchUrl,
ReleaseStageId = projectService.ReleaseStageId,
AgentPoolId = project.AgentPoolId,
OrganizationId = organization.OrganizationId,
ProjectId = project.ProjectId,
FeatureId = newFeature.ProjectFeatureId,
ProjectExternalId = serviceCredential.ProjectExternalId,
ProjectExternalEndpointId = project.ProjectExternalEndpointId,
ProjectExternalGitEndpoint = project.ProjectExternalGitEndpoint,
ProjectVSTSFakeName = project.ProjectVSTSFakeName,
ProjectVSTSFakeId = project.ProjectVSTSFakeId,
OrganizationName = organization.Name,
ProjectName = serviceCredential.ProjectName,
FeatureName = newFeature.Name,
CMSType = serviceCredential.CMSType,
CMSAccountId = serviceCredential.AccountId,
CMSAccountName = serviceCredential.AccountName,
CMSAccessId = serviceCredential.AccessId,
CMSAccessSecret = serviceCredential.AccessSecret,
CMSAccessToken = serviceCredential.AccessToken,
CPSType = project.OrganizationCPS.Type,
CPSAccessId = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessId),
CPSAccessName = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessName),
CPSAccessSecret = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessSecret),
CPSAccessRegion = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessRegion),
TemplateAccess = projectService.ProjectServiceTemplate.TemplateAccess,
IsImported = projectService.IsImported,
NeedCredentials = projectService.ProjectServiceTemplate.NeedCredentials,
RepositoryCMSType = serviceCredential.CMSType,
RepositoryAccessId = serviceCredential.AccessId,
RepositoryAccessSecret = serviceCredential.AccessSecret,
RepositoryAccessToken = serviceCredential.AccessToken,
UserId = loggedUserId
});
}
_userRepository.Update(user);
await _userRepository.SaveChanges();
await _domainManagerService.AddResult("FeatureId", newFeature.ProjectFeatureId);
//send events
foreach (var @event in @events)
{
await _eventBusService.Publish(queueName : "ProjectFeatureServiceCreatedEvent", @event : @event);
}
}
public async Task CompleteProjectFeature(Guid organizationId, Guid projectId, Guid featureId, bool deleteInfrastructure)
{
string loggedUserId = _identityService.GetUserId();
DomainModels.User user = await _userRepository.GetUser(loggedUserId);
DomainModels.Organization organization = user.FindOrganizationById(organizationId);
if (organization == null)
{
await _domainManagerService.AddNotFound($"The organzation with id {organizationId} does not exists.");
return;
}
DomainModels.Project project = user.FindProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return;
}
DomainModels.PipelineRole role = user.GetRoleInProject(projectId);
if (role != DomainModels.PipelineRole.ProjectAdmin)
{
await _domainManagerService.AddForbidden($"You are not authorized to complete features in this project.");
return;
}
if (project.Status != DomainModels.EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The project with id {projectId} must be in status Active to ask for pull request.");
return;
}
DomainModels.ProjectFeature feature = project.GetFeatureById(featureId);
if (feature == null)
{
await _domainManagerService.AddNotFound($"The feature with id {featureId} does not exists.");
return;
}
if (feature.Status != DomainModels.EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The feature with id {featureId} must be in status Active to to ask for pull request.");
return;
}
//if (feature.IsCompleted())
//{
// await _domainManagerService.AddConflict($"The feature with id {featureId} has already been completed.");
// return;
//}
//services asociated (TODO: services on demand)
List <ProjectFeatureServiceCompletedEvent> @events = new List <ProjectFeatureServiceCompletedEvent>();
foreach (var item in feature.Services)
{
DomainModels.ProjectService projectService = project.GetServiceById(item.ProjectServiceId);
if (projectService == null)
{
await _domainManagerService.AddConflict($"The pipe id {item} does not exists.");
return;
}
@events.Add(new ProjectFeatureServiceCompletedEvent(_correlationId)
{
ServiceId = item.ProjectServiceId,
ServiceExternalId = projectService.ProjectServiceExternalId,
ServiceExternalUrl = projectService.ProjectServiceExternalUrl,
ServiceName = projectService.Name,
ServiceTemplateUrl = projectService.ProjectServiceTemplate.Url,
CommitStageId = item.CommitStageId,
ReleaseStageId = item.ReleaseStageId
});
}
user.CompleteProjectFeature(organizationId, projectId, featureId);
_userRepository.Update(user);
await _userRepository.SaveChanges();
var @event = new ProjectFeatureCompletedEvent(_correlationId)
{
OrganizationExternalId = project.OrganizationExternalId,
OrganizationId = organization.OrganizationId,
OrganizationName = organization.Name,
ProjectId = project.ProjectId,
Services = @events,
ProjectExternalId = project.ProjectExternalId,
ProjectExternalEndpointId = project.ProjectExternalEndpointId,
ProjectVSTSFakeName = project.ProjectVSTSFakeName,
ProjectName = project.Name,
FeatureId = feature.ProjectFeatureId,
FeatureName = feature.Name,
CMSType = project.OrganizationCMS.Type,
CMSAccountId = _dataProtectorService.Unprotect(project.OrganizationCMS.AccountId),
CMSAccountName = _dataProtectorService.Unprotect(project.OrganizationCMS.AccountName),
CMSAccessId = _dataProtectorService.Unprotect(project.OrganizationCMS.AccessId),
CMSAccessSecret = _dataProtectorService.Unprotect(project.OrganizationCMS.AccessSecret),
CMSAccessToken = _dataProtectorService.Unprotect(project.OrganizationCMS.AccessToken),
DeleteInfrastructure = deleteInfrastructure
};
//Cloud Provider Data
@event.CPSType = project.OrganizationCPS.Type;
@event.CPSAccessId = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessId);
@event.CPSAccessName = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessName);
@event.CPSAccessSecret = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessSecret);
@event.CPSAccessRegion = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessRegion);
@event.CPSAccessAppId = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessAppId);
@event.CPSAccessAppSecret = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessAppSecret);
@event.CPSAccessDirectory = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessDirectory);
await _eventBusService.Publish(queueName : "ProjectFeatureCompletedEvent", @event : @event);
}
public async Task CreateProjectServiceEnvironmentVariables(Guid organizationId, Guid projectId, Guid serviceId, Guid environmentId, ProjectServiceEnvironmentVariablePostRp resource)
{
string loggedUserId = _identityService.GetUserId();
DomainModels.User user = await _userRepository.GetUser(loggedUserId);
DomainModels.Organization organization = user.FindOrganizationById(organizationId);
if (organization == null)
{
await _domainManagerService.AddNotFound($"The organzation with id {organizationId} does not exists.");
return;
}
DomainModels.Project project = user.FindProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return;
}
DomainModels.PipelineRole role = user.GetRoleInProject(projectId);
if (role != DomainModels.PipelineRole.ProjectAdmin)
{
await _domainManagerService.AddForbidden($"You are not authorized to create environments variables in this project.");
return;
}
if (project.Status != DomainModels.EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The project with id {projectId} must be in status Active to add a new feature.");
return;
}
DomainModels.ProjectService projectService = project.GetServiceById(serviceId);
if (projectService == null)
{
await _domainManagerService.AddNotFound($"The project service with id {serviceId} does not exists.");
return;
}
if (projectService.Status != DomainModels.EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The pipe with id {serviceId} must be in status Active to add/modify variables.");
return;
}
DomainModels.ProjectServiceEnvironment environment = projectService.GetServiceEnvironment(environmentId);
if (environment == null)
{
await _domainManagerService.AddNotFound($"The environment with id {environmentId} does not exists.");
return;
}
foreach (var resourceVariable in resource.Items)
{
if (string.IsNullOrEmpty(resourceVariable.Name) || string.IsNullOrEmpty(resourceVariable.Value))
{
await _domainManagerService.AddConflict($"The environment variable name/value is mandatory.");
return;
}
var variable = environment.GetVariableByName(resourceVariable.Name);
if (variable != null)
{
environment.SetVariable(resourceVariable.Name, resourceVariable.Value);
}
else
{
environment.AddVariable(resourceVariable.Name, resourceVariable.Value);
}
}
_userRepository.Update(user);
await _userRepository.SaveChanges();
var @event = new ProjectEnvironmentCreatedEvent(_correlationId)
{
OrganizationId = organization.OrganizationId,
OrganizationName = organization.Name,
ProjectId = project.ProjectId,
ProjectExternalId = project.ProjectExternalId,
ProjectExternalEndpointId = project.ProjectExternalEndpointId,
ProjectVSTSFakeName = project.ProjectVSTSFakeName,
ProjectName = project.Name,
CMSType = project.OrganizationCMS.Type,
CMSAccountId = _dataProtectorService.Unprotect(project.OrganizationCMS.AccountId),
CMSAccountName = _dataProtectorService.Unprotect(project.OrganizationCMS.AccountName),
CMSAccessId = _dataProtectorService.Unprotect(project.OrganizationCMS.AccessId),
CMSAccessSecret = _dataProtectorService.Unprotect(project.OrganizationCMS.AccessSecret),
CMSAccessToken = _dataProtectorService.Unprotect(project.OrganizationCMS.AccessToken),
ReleseStageId = projectService.ReleaseStageId.Value
};
@event.Environments = new List <ProjectEnvironmentItemCreatedEvent>();
foreach (var item in projectService.Environments)
{
var parentEnvironment = project.GetEnvironments().First(x => x.ProjectEnvironmentId == item.ProjectEnvironmentId);
var serviceEnvironment = new ProjectEnvironmentItemCreatedEvent();
serviceEnvironment.Name = parentEnvironment.Name;
serviceEnvironment.RequiredApproval = parentEnvironment.RequiresApproval;
serviceEnvironment.Rank = parentEnvironment.Rank;
serviceEnvironment.Variables = new List <ProjectEnvironmentItemVariableCreatedEvent>();
foreach (var variable in parentEnvironment.Variables)
{
serviceEnvironment.Variables.Add(new ProjectEnvironmentItemVariableCreatedEvent()
{
Name = variable.Name,
Value = variable.Value
});
}
foreach (var variable in item.Variables)
{
serviceEnvironment.Variables.Add(new ProjectEnvironmentItemVariableCreatedEvent()
{
Name = variable.Name,
Value = variable.Value
});
}
@event.Environments.Add(serviceEnvironment);
}
//Cloud Provider Data
@event.CPSType = project.OrganizationCPS.Type;
@event.CPSAccessId = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessId);
@event.CPSAccessName = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessName);
@event.CPSAccessSecret = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessSecret);
@event.CPSAccessRegion = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessRegion);
await _eventBusService.Publish(queueName : "ProjectEnvironmentCreatedEvent", @event : @event);
}
