public void UpdateProjectService(Guid organizationId, Guid projectId, Guid serviceId, string name, string description)
{
Organization organization = FindOrganizationById(organizationId);
if (organization == null)
{
throw new ApplicationException($"The organization with id {organizationId} does not exists");
}
Project project = organization.GetProjectById(projectId);
if (project == null)
{
throw new ApplicationException($"The project with id {projectId} does not exists");
}
ProjectService projectService = project.GetServiceById(serviceId);
if (projectService == null)
{
throw new ApplicationException($"The pipe with id {serviceId} does not exists");
}
projectService.UpdateBasicInformation(name, description);
projectService.Audit(this.Id);
}
public void DeleteProjectService(Guid organizationId, Guid projectId, Guid serviceId)
{
Organization organization = FindOrganizationById(organizationId);
if (organization == null)
{
throw new ApplicationException($"The organization with id {organizationId} does not exists");
}
Project project = organization.GetProjectById(projectId);
if (project == null)
{
throw new ApplicationException($"The project with id {projectId} does not exists");
}
ProjectService projectService = project.GetServiceById(serviceId);
if (projectService == null)
{
throw new ApplicationException($"The pipe with id {serviceId} does not exists");
}
projectService.Delete(this.Id);
}
public async Task CreateProjectServiceEvent(Guid organizationId, Guid projectId, Guid serviceId, ProjectServiceEventPostRp resource)
{
DomainModels.Organization organization = await _organizationRepository.GetOrganizationById(organizationId);
if (organization == null)
{
await _domainManagerService.AddNotFound($"The organzation with id {organizationId} does not exists.");
return;
}
DomainModels.Project project = organization.GetProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return;
}
DomainModels.ProjectService service = project.GetServiceById(serviceId);
if (service == null)
{
await _domainManagerService.AddNotFound($"The project pipe with id {serviceId} does not exists.");
return;
}
service.AddEvent(BaseEventType.Build, resource.GetEventType().GetDescription(), resource.Message.Text, resource.Status, JsonConvert.SerializeObject(resource.DetailedMessage), JsonConvert.SerializeObject(resource.DetailedMessage), JsonConvert.SerializeObject(resource.Resource), resource.Date);
_organizationRepository.Update(organization);
await _organizationRepository.SaveChanges();
}
public async Task <ProjectServiceEventListRp> GetProjectServiceEvents(Guid organizationId, Guid projectId, Guid serviceId, BaseEventType baseEventType)
{
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(null);
}
DomainModels.Project project = user.FindProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return(null);
}
DomainModels.ProjectService service = project.GetServiceById(serviceId);
if (service == null)
{
await _domainManagerService.AddNotFound($"The project pipe with id {serviceId} does not exists.");
return(null);
}
ProjectServiceEventListRp list = new ProjectServiceEventListRp();
if (service.Events != null)
{
if (baseEventType == BaseEventType.None)
{
list.Items = service.Events.Select(x => new ProjectServiceEventListItemRp
{
EventType = x.EventType,
EventDescription = x.EventDescription,
EventStatus = x.EventStatus,
CreationDate = x.CreationDate,
EventDate = x.EventDate
}).OrderByDescending(x => x.EventDate).Take(10).ToList();
}
else
{
list.Items = service.Events.Where(x => x.BaseEventType == baseEventType).Select(x => new ProjectServiceEventListItemRp
{
EventType = x.EventType,
EventDescription = x.EventDescription,
EventStatus = x.EventStatus,
CreationDate = x.CreationDate,
EventDate = x.EventDate
}).OrderByDescending(x => x.EventDate).Take(10).ToList();
}
}
return(list);
}
public async Task CompleteApprovalProjectService(Guid organizationId, Guid projectId, Guid serviceId, int approvalId, ProjectServiceApprovalPutRp resource)
{
string loggedUserId = _identityService.GetUserId();
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 = organization.GetProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return;
}
if (project.Status != EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The project with id {projectId} must be in status Active to modify a service.");
return;
}
DomainModels.ProjectService service = project.GetServiceById(serviceId);
if (service == null)
{
await _domainManagerService.AddNotFound($"The project pipe with id {serviceId} does not exists.");
return;
}
if (service.Status != EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The pipe with id {serviceId} must be in status Active to complete an approval.");
return;
}
CMSPipelineApprovalParamModel completeApprovalOptions = new CMSPipelineApprovalParamModel();
completeApprovalOptions.VSTSAPIVersion = _vstsOptions.Value.ApiVersion;
completeApprovalOptions.VSTSAccountName = project.OrganizationCMS.Type == ConfigurationManagementService.VSTS ? _dataProtectorService.Unprotect(project.OrganizationCMS.AccountName) : _fakeAccountOptions.Value.AccountId;
completeApprovalOptions.VSTSAccessSecret = project.OrganizationCMS.Type == ConfigurationManagementService.VSTS ? _dataProtectorService.Unprotect(project.OrganizationCMS.AccessSecret) : _fakeAccountOptions.Value.AccessSecret;
completeApprovalOptions.VSTSAccountProjectId = project.OrganizationCMS.Type == ConfigurationManagementService.VSTS ? project.Name : project.ProjectVSTSFakeName;
completeApprovalOptions.ProjectName = project.Name;
completeApprovalOptions.ProjectExternalId = project.OrganizationCMS.Type == ConfigurationManagementService.VSTS ? project.ProjectExternalId : project.ProjectVSTSFakeId;
completeApprovalOptions.ApprovalId = approvalId;
completeApprovalOptions.Status = resource.Status;
completeApprovalOptions.Comments = resource.Comments;
await _cmsPipelineService.CompleteApproval(completeApprovalOptions);
}
public async Task <ProjectServiceDeliveryListRp> GetProjectServiceDeliveries(Guid organizationId, Guid projectId, Guid serviceId)
{
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(null);
}
DomainModels.Project project = user.FindProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return(null);
}
DomainModels.ProjectService service = project.GetServiceById(serviceId);
if (service == null)
{
await _domainManagerService.AddNotFound($"The pipe with id {serviceId} does not exists.");
return(null);
}
ProjectServiceDeliveryListRp list = new ProjectServiceDeliveryListRp();
if (service.Deliveries != null)
{
list.Items = service.Deliveries
.OrderByDescending(x => x.DeliveryDate)
.Take(5)
.Select(x => new ProjectServiceDeliveryListItemRp
{
VersionId = x.VersionId,
VersionName = x.VersionName,
DeliveryDate = x.DeliveryDate,
Data = JsonConvert.DeserializeObject <ProjectServiceDeliveryDataRp>(x.Data)
}).ToList();
}
return(list);
}
public async Task <CPSCloudResourceSummaryModel> GetProjectServiceCloudSummary(Guid organizationId, Guid projectId, Guid serviceId)
{
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(null);
}
DomainModels.Project project = user.FindProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return(null);
}
DomainModels.ProjectService service = project.GetServiceById(serviceId);
if (service == null)
{
await _domainManagerService.AddNotFound($"The project pipe with id {serviceId} does not exists.");
return(null);
}
var environments = project.GetEnvironments().Select(x => x.Name).ToList();
CPSAuthCredentialModel authCredentials = new CPSAuthCredentialModel();
authCredentials.AccessId = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessId);
authCredentials.AccessName = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessName);
authCredentials.AccessSecret = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessSecret);
authCredentials.AccessRegion = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessRegion);
authCredentials.AccessAppId = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessAppId);
authCredentials.AccessAppSecret = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessAppSecret);
authCredentials.AccessDirectory = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessDirectory);
var summary = await _cpsQueryService(project.OrganizationCPS.Type).GetSummary(organization.Name, project.Name, service.Name, environments, "Root", authCredentials);
return(summary);
}
public async Task <ProjectServiceActivityListRp> GetProjectServiceActivities(Guid organizationId, Guid projectId, Guid serviceId)
{
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(null);
}
DomainModels.Project project = user.FindProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return(null);
}
DomainModels.ProjectService service = project.GetServiceById(serviceId);
if (service == null)
{
await _domainManagerService.AddNotFound($"The pipe with id {serviceId} does not exists.");
return(null);
}
ProjectServiceActivityListRp list = new ProjectServiceActivityListRp();
if (service.Activities != null)
{
list.Items = service.Activities.Select(x => new ProjectServiceActivityListItemRp
{
Name = x.Name,
Log = x.Log,
ActivityStatus = x.ActivityStatus,
CreationDate = x.CreationDate
}).OrderBy(x => x.CreationDate).ToList();
}
return(list);
}
public async Task UpdateProjectService(Guid organizationId, Guid projectId, Guid serviceId, ProjectServicePutRp resource)
{
string loggedUserId = _identityService.GetUserId();
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 = organization.GetProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return;
}
if (project.Status != EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The project with id {projectId} must be in status Active to modify a service.");
return;
}
DomainModels.ProjectService service = project.GetServiceById(serviceId);
if (service == null)
{
await _domainManagerService.AddNotFound($"The project pipe with id {serviceId} does not exists.");
return;
}
user.UpdateProjectService(organizationId, projectId, serviceId, resource.Name, resource.Description);
_userRepository.Update(user);
await _userRepository.SaveChanges();
}
public async Task <ProjectServiceGetRp> GetProjectServiceById(Guid organizationId, Guid projectId, Guid serviceId)
{
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(null);
}
DomainModels.Project project = organization.GetProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return(null);
}
DomainModels.ProjectService service = project.GetServiceById(serviceId);
if (service == null)
{
return(null);
}
ProjectServiceGetRp serviceRp = new ProjectServiceGetRp
{
ProjectServiceId = service.ProjectServiceId,
Name = service.Name,
Description = service.Description,
Template = service.ProjectServiceTemplate.Name,
Status = service.Status,
PipelineStatus = service.PipelineStatus,
ServiceExternalUrl = service.ProjectServiceExternalUrl,
GitProviderType = service.OrganizationCMS.Type,
};
return(serviceRp);
}
public async Task <ProjectServiceFeatureListRp> GetProjectServiceFeaturesById(Guid organizationId, Guid projectId, Guid serviceId)
{
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(null);
}
DomainModels.Project project = user.FindProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return(null);
}
DomainModels.ProjectService service = project.GetServiceById(serviceId);
if (service == null)
{
return(null);
}
ProjectServiceFeatureListRp featureListRp = new ProjectServiceFeatureListRp
{
Items = service.Features.Select(x => new ProjectServiceFeatureListItemRp()
{
FeatureId = x.ProjectFeatureId,
FeatureName = x.ProjectFeature.Name
}).ToList()
};
return(featureListRp);
}
public async Task CreateReleaseProjectService(Guid organizationId, Guid projectId, Guid serviceId)
{
string loggedUserId = _identityService.GetUserId();
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 = organization.GetProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return;
}
if (project.Status != EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The project with id {projectId} must be in status Active to modify a service.");
return;
}
DomainModels.ProjectService service = project.GetServiceById(serviceId);
if (service == null)
{
await _domainManagerService.AddNotFound($"The project pipe with id {serviceId} does not exists.");
return;
}
if (service.Status != EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The pipe with id {serviceId} must be in status Active to request a Request.");
return;
}
if (string.IsNullOrEmpty(service.LastBuildSuccessVersionId))
{
await _domainManagerService.AddConflict($"The project service with id {serviceId} does not have any success build yet.");
return;
}
var serviceCredential = this._cloudCredentialService.ProjectServiceCredentialResolver(project, service);
CMSPipelineReleaseParamModel releaseBuildOptions = new CMSPipelineReleaseParamModel();
releaseBuildOptions.VSTSAPIVersion = _vstsOptions.Value.ApiVersion;
releaseBuildOptions.VSTSAccountName = serviceCredential.AccountName;
releaseBuildOptions.VSTSAccessSecret = serviceCredential.AccessSecret;
releaseBuildOptions.VSTSAccountProjectId = serviceCredential.AccountProjectId;
releaseBuildOptions.ProjectName = serviceCredential.ProjectName;
releaseBuildOptions.ProjectExternalId = serviceCredential.ProjectExternalId;
releaseBuildOptions.ReleaseDefinitionId = service.ReleaseStageId.Value;
releaseBuildOptions.Alias = service.Name;
releaseBuildOptions.VersionId = int.Parse(service.LastBuildSuccessVersionId);
releaseBuildOptions.VersionName = service.LastBuildSuccessVersionName;
releaseBuildOptions.Description = "Release created from PipelineSpace";
await _cmsPipelineService.CreateRelease(releaseBuildOptions);
}
//actions
public async Task CreateBuildProjectService(Guid organizationId, Guid projectId, Guid serviceId)
{
string loggedUserId = _identityService.GetUserId();
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 = organization.GetProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return;
}
if (project.Status != EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The project with id {projectId} must be in status Active to modify a service.");
return;
}
DomainModels.ProjectService service = project.GetServiceById(serviceId);
if (service == null)
{
await _domainManagerService.AddNotFound($"The project pipe with id {serviceId} does not exists.");
return;
}
if (service.Status != EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The pipe with id {serviceId} must be in status Active to request a Build.");
return;
}
var serviceCredential = this._cloudCredentialService.ProjectServiceCredentialResolver(project, service);
CMSPipelineAgentQueueParamModel getQueueOptions = new CMSPipelineAgentQueueParamModel();
getQueueOptions.VSTSAPIVersion = _vstsOptions.Value.ApiVersion;
getQueueOptions.CMSType = serviceCredential.CMSType;
getQueueOptions.VSTSAccountName = serviceCredential.AccountName;
getQueueOptions.VSTSAccessSecret = serviceCredential.AccessSecret;
getQueueOptions.VSTSAccountProjectId = serviceCredential.AccountProjectId;
getQueueOptions.ProjectName = serviceCredential.ProjectName;
getQueueOptions.AgentPoolId = project.AgentPoolId;
var queue = await _cmsPipelineService.GetQueue(getQueueOptions);
if (queue == null)
{
await _domainManagerService.AddConflict($"The agent pool id {project.AgentPoolId} is not available.");
return;
}
CMSPipelineBuildParamModel queueBuildOptions = new CMSPipelineBuildParamModel();
queueBuildOptions.VSTSAPIVersion = _vstsOptions.Value.ApiVersion;
queueBuildOptions.VSTSAccountName = serviceCredential.AccountName;
queueBuildOptions.VSTSAccessSecret = serviceCredential.AccessSecret;
queueBuildOptions.VSTSAccountProjectId = serviceCredential.AccountProjectId;
queueBuildOptions.ProjectName = serviceCredential.ProjectName;
queueBuildOptions.ProjectExternalId = serviceCredential.ProjectExternalId;
queueBuildOptions.QueueId = queue.QueueId;
queueBuildOptions.BuildDefinitionId = service.CommitStageId.Value;
queueBuildOptions.SourceBranch = service.BranchName;
await _cmsPipelineService.CreateBuild(queueBuildOptions);
var @event = new ProjectServiceBuildQueuedEvent(_correlationId)
{
OrganizationId = organization.OrganizationId,
ProjectId = project.ProjectId,
ServiceId = service.ProjectServiceId
};
await _eventBusService.Publish(queueName : "ProjectServiceBuildQueuedEvent", @event : @event);
}
public async Task DeleteProjectService(Guid organizationId, Guid projectId, Guid serviceId)
{
string loggedUserId = _identityService.GetUserId();
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 = organization.GetProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return;
}
if (project.Status != EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The project with id {projectId} must be in status Active to modify a service.");
return;
}
DomainModels.ProjectService service = project.GetServiceById(serviceId);
if (service == null)
{
await _domainManagerService.AddNotFound($"The project pipe with id {serviceId} does not exists.");
return;
}
if (service.Status != EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The pipe with id {serviceId} must be in status Active to be modified/deleted.");
return;
}
/*Check If any feature is associated with the service*/
var features = project.GetFeatures();
foreach (var feature in features)
{
var featureService = feature.GetFeatureServiceById(serviceId);
if (featureService != null)
{
await _domainManagerService.AddConflict($"The are active features ({feature.Name}) using the service, you cannot delete the service.");
return;
}
}
user.DeleteProjectService(organizationId, projectId, serviceId);
_userRepository.Update(user);
await _userRepository.SaveChanges();
if (project.OrganizationCPS == null)
{
project.OrganizationCPS = new OrganizationCPS {
Type = CloudProviderService.None
}
}
;
//send event
var projectServiceDeletedEvent = new ProjectServiceDeletedEvent(_correlationId)
{
OrganizationExternalId = project.OrganizationExternalId,
OrganizationName = organization.Name,
ProjectName = project.Name,
ServiceName = service.Name,
ProjectVSTSFakeName = project.ProjectVSTSFakeName,
ProjectExternalId = project.ProjectExternalId,
ProjectServiceExternalId = service.ProjectServiceExternalId,
CommitStageId = service.CommitStageId,
ReleaseStageId = service.ReleaseStageId,
CommitServiceHookId = service.CommitServiceHookId,
CodeServiceHookId = service.CodeServiceHookId,
ReleaseStartedServiceHookId = service.ReleaseStartedServiceHookId,
ReleasePendingApprovalServiceHookId = service.ReleasePendingApprovalServiceHookId,
ReleaseCompletedApprovalServiceHookId = service.ReleaseCompletedApprovalServiceHookId,
ReleaseServiceHookId = service.ReleaseServiceHookId,
Environments = project.GetEnvironments().Select(x => x.Name).ToList(),
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),
CPSType = project.OrganizationCPS.Type,
CPSAccessId = project.OrganizationCPS.Type == CloudProviderService.None ? string.Empty : _dataProtectorService.Unprotect(project.OrganizationCPS.AccessId),
CPSAccessName = project.OrganizationCPS.Type == CloudProviderService.None ? string.Empty : _dataProtectorService.Unprotect(project.OrganizationCPS.AccessName),
CPSAccessSecret = project.OrganizationCPS.Type == CloudProviderService.None ? string.Empty : _dataProtectorService.Unprotect(project.OrganizationCPS.AccessSecret),
CPSAccessRegion = project.OrganizationCPS.Type == CloudProviderService.None ? string.Empty : _dataProtectorService.Unprotect(project.OrganizationCPS.AccessRegion),
CPSAccessAppId = project.OrganizationCPS.Type == CloudProviderService.None ? string.Empty : _dataProtectorService.Unprotect(project.OrganizationCPS.AccessAppId),
CPSAccessAppSecret = project.OrganizationCPS.Type == CloudProviderService.None ? string.Empty : _dataProtectorService.Unprotect(project.OrganizationCPS.AccessAppSecret),
CPSAccessDirectory = project.OrganizationCPS.Type == CloudProviderService.None ? string.Empty : _dataProtectorService.Unprotect(project.OrganizationCPS.AccessDirectory),
SourceEvent = DomainModels.Enums.SourceEvent.Service
};
await _eventBusService.Publish(queueName : "ProjectServiceDeletedEvent", @event : projectServiceDeletedEvent);
}
public async Task CreateProjectFeatureService(Guid organizationId, Guid projectId, Guid featureId, ProjectFeatureServicePostRp resource)
{
string loggedUserId = _identityService.GetUserId();
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 != EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The project with id {projectId} must be in status Active to add a new feature service.");
return;
}
DomainModels.ProjectFeature feature = project.GetFeatureById(featureId);
if (feature == null)
{
await _domainManagerService.AddNotFound($"The project feature with id {featureId} does not exists.");
return;
}
if (feature.Status != EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The project feature with id {featureId} must be in status Active to add a new feature service.");
return;
}
if (resource.Services.Length == 0)
{
await _domainManagerService.AddConflict($"At least one pipe must be included.");
return;
}
List <ProjectFeatureServiceCreatedEvent> projectFeatureServiceCreatedEventList = new List <ProjectFeatureServiceCreatedEvent>();
foreach (var item in resource.Services)
{
DomainModels.ProjectService projectService = project.GetServiceById(item);
if (projectService == null)
{
await _domainManagerService.AddConflict($"The pipe with id {item} does not exists.");
return;
}
if (projectService.Status != EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The pipe with id {item} must be in status Active to be added as a feature service.");
return;
}
DomainModels.ProjectFeatureService projectFeatureService = feature.GetFeatureServiceById(item);
if (projectFeatureService != null)
{
await _domainManagerService.AddConflict($"The pipe with id {item} already exists in the feature.");
return;
}
var variables = projectService.Environments.First(x => x.ProjectEnvironment.Type == EnvironmentType.Root).Variables;
feature.AddService(item, variables);
projectFeatureServiceCreatedEventList.Add(new ProjectFeatureServiceCreatedEvent(_correlationId)
{
OrganizationId = organization.OrganizationId,
ProjectId = project.ProjectId,
FeatureId = feature.ProjectFeatureId,
ProjectExternalId = project.ProjectExternalId,
ProjectExternalEndpointId = project.ProjectExternalEndpointId,
ProjectExternalGitEndpoint = project.ProjectExternalGitEndpoint,
ProjectVSTSFakeName = project.ProjectVSTSFakeName,
ProjectVSTSFakeId = project.ProjectVSTSFakeId,
OrganizationName = organization.Name,
ProjectName = project.Name,
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),
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),
ServiceId = item,
ServiceExternalId = projectService.ProjectServiceExternalId,
ServiceExternalUrl = projectService.ProjectServiceExternalUrl,
ServiceName = projectService.Name,
InternalServiceName = projectService.InternalName,
ServiceTemplateUrl = projectService.ProjectServiceTemplate.Url,
ReleaseStageId = projectService.ReleaseStageId,
AgentPoolId = project.AgentPoolId,
UserId = loggedUserId
});
}
_userRepository.Update(user);
await _userRepository.SaveChanges();
//send events
foreach (var @event in projectFeatureServiceCreatedEventList)
{
await _eventBusService.Publish(queueName : "ProjectFeatureServiceCreatedEvent", @event : @event);
}
}
public async Task <ProjectServicePipelineGetRp> GetProjectServicePipelineById(Guid organizationId, Guid projectId, Guid serviceId)
{
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(null);
}
DomainModels.Project project = user.FindProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return(null);
}
DomainModels.ProjectService service = project.GetServiceById(serviceId);
if (service == null)
{
return(null);
}
ProjectServicePipelineGetRp servicePipelineRp = new ProjectServicePipelineGetRp
{
Name = service.Name,
Description = service.Description,
Status = service.Status,
PipeType = service.PipeType,
Phases = new List <ProjectServicePipelinePhaseGetRp>()
};
servicePipelineRp.Phases.Add(new ProjectServicePipelinePhaseGetRp()
{
Type = "Build",
Name = "Build",
Rank = 1,
LastStatusCode = service.LastPipelineBuildStatus.ToString(),
LastStatusDescription = service.LastPipelineBuildStatus.GetDescription(),
LastVersionId = service.LastBuildVersionId,
LastVersionName = service.LastBuildVersionName,
LastSuccessVersionId = service.LastBuildSuccessVersionId,
LastSuccessVersionName = service.LastBuildSuccessVersionName,
LastApprovalId = string.Empty
});
foreach (var environment in service.Environments)
{
servicePipelineRp.Phases.Add(new ProjectServicePipelinePhaseGetRp()
{
Type = "Release",
Name = environment.ProjectEnvironment.Name,
Rank = environment.ProjectEnvironment.Rank + 1,
LastStatusCode = string.IsNullOrEmpty(environment.LastStatusCode) ? PipelineReleaseStatus.Pending.ToString() : environment.LastStatusCode,
LastStatusDescription = string.IsNullOrEmpty(environment.LastStatus) ? PipelineReleaseStatus.Pending.ToString() : environment.LastStatus,
LastVersionId = environment.LastVersionId,
LastVersionName = environment.LastVersionName,
LastSuccessVersionId = environment.LastSuccessVersionId,
LastSuccessVersionName = environment.LastSuccessVersionName,
LastApprovalId = environment.LastApprovalId
});
}
//Order
servicePipelineRp.Phases = servicePipelineRp.Phases.OrderBy(x => x.Rank).ToList();
return(servicePipelineRp);
}
public async Task CreateProjectServiceEvent(Guid organizationId, Guid projectId, Guid serviceId, ProjectServiceEventPostRp resource)
{
DomainModels.Organization organization = await _organizationRepository.GetOrganizationById(organizationId);
if (organization == null)
{
await _domainManagerService.AddNotFound($"The organzation with id {organizationId} does not exists.");
return;
}
DomainModels.Project project = organization.GetProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return;
}
DomainModels.ProjectService service = project.GetServiceById(serviceId);
if (service == null)
{
await _domainManagerService.AddNotFound($"The project pipe with id {serviceId} does not exists.");
return;
}
/*PIPELINE STATUS###########################################################################################################*/
/*##########################################################################################################################*/
string eventStatus = string.Empty;
DateTime eventDate = DateTime.UtcNow;
BaseEventType baseEventType = BaseEventType.Build;
//update pipeline status when build
if (resource.GetEventType() == PipelineEventType.BuildStarted)
{
baseEventType = BaseEventType.Build;
eventStatus = "Queued";
if (eventDate > service.LastBuildEventDate)
{
service.PipelineStatus = PipelineStatus.Building;
service.LastPipelineBuildStatus = PipelineBuildStatus.Building;
service.LastBuildEventDate = eventDate;
}
}
if (resource.GetEventType() == PipelineEventType.BuildCompleted)
{
var buildModel = resource.BuildBuildModel();
eventStatus = buildModel.Status.FirstCharToUpper();
eventDate = buildModel.FinishTime;
baseEventType = BaseEventType.Build;
service.LastBuildVersionId = buildModel.Id.ToString();
service.LastBuildVersionName = buildModel.BuildNumber;
if (eventDate > service.LastBuildEventDate)
{
if (buildModel.Status.Equals("Succeeded", StringComparison.InvariantCultureIgnoreCase))
{
service.PipelineStatus = PipelineStatus.BuildSucceeded;
service.LastPipelineBuildStatus = PipelineBuildStatus.BuildSucceeded;
service.LastBuildSuccessVersionId = buildModel.Id.ToString();
service.LastBuildSuccessVersionName = buildModel.BuildNumber;
}
if (buildModel.Status.Equals("Failed", StringComparison.InvariantCultureIgnoreCase) ||
buildModel.Status.Equals("Error", StringComparison.InvariantCultureIgnoreCase))
{
service.PipelineStatus = PipelineStatus.BuildFailed;
service.LastPipelineBuildStatus = PipelineBuildStatus.BuildFailed;
}
if (buildModel.Status.Equals("Canceled", StringComparison.InvariantCultureIgnoreCase))
{
service.PipelineStatus = PipelineStatus.BuildCanceled;
service.LastPipelineBuildStatus = PipelineBuildStatus.BuildCanceled;
}
service.LastBuildEventDate = eventDate;
}
//Delivery
service.AddDeliveryBuildCompleted(buildModel.Id, buildModel.BuildNumber, eventStatus, eventDate);
}
//update pipeline status when release
if (resource.GetEventType() == PipelineEventType.ReleaseStarted)
{
var releaseModel = resource.BuildReleaseStartedModel();
eventStatus = releaseModel.Environment.Status.FirstCharToUpper();
eventDate = releaseModel.Release.CreatedOn;
baseEventType = BaseEventType.Release;
var environment = service.Environments.FirstOrDefault(x => x.ProjectEnvironment.Name.Equals(releaseModel.Environment.Name, StringComparison.InvariantCultureIgnoreCase));
if (environment.LastEventDate < eventDate)
{
environment.LastStatus = releaseModel.Environment.Status.FirstCharToUpper();
environment.LastStatusCode = PipelineReleaseStatus.Deploying.ToString();
environment.LastEventDate = eventDate;
}
if (eventDate > service.LasReleaseEventDate)
{
service.PipelineStatus = PipelineStatus.Deploying;
service.LastPipelineReleaseStatus = PipelineReleaseStatus.Deploying;
service.LasReleaseEventDate = eventDate;
}
//Delivery
service.AddDeliveryReleaseStarted(int.Parse(releaseModel.VersionId),
releaseModel.VersionName,
releaseModel.Release.Environments.Select(x => new Domain.ModelUtility.DeliveryEnvironmentModel()
{
Name = x.Name, Rank = x.Rank, Status = x.Status.FirstCharToUpper()
}).ToList());
}
if (resource.GetEventType() == PipelineEventType.ReleasePendingApproval)
{
var releaseApprovalModel = resource.BuildReleaseApprovalModel();
eventStatus = "Release approval pending";
eventDate = releaseApprovalModel.Approval.CreatedOn;
baseEventType = BaseEventType.Release;
var environment = service.Environments.FirstOrDefault(x => x.ProjectEnvironment.Name.Equals(releaseApprovalModel.Approval.ReleaseEnvironment.Name, StringComparison.InvariantCultureIgnoreCase));
if (environment.LastEventDate < eventDate)
{
environment.LastStatus = "Release approval pending";
environment.LastStatusCode = PipelineReleaseStatus.DeployPendingApproval.ToString();
environment.LastApprovalId = releaseApprovalModel.Approval.Id.ToString();
environment.LastEventDate = eventDate;
}
if (eventDate > service.LasReleaseEventDate)
{
service.PipelineStatus = PipelineStatus.DeployPendingApproval;
service.LastPipelineReleaseStatus = PipelineReleaseStatus.DeployPendingApproval;
service.LasReleaseEventDate = eventDate;
}
//Delivery
service.UpdateDeliveryReleaseStatus(int.Parse(releaseApprovalModel.VersionId), releaseApprovalModel.VersionName, releaseApprovalModel.Approval.ReleaseEnvironment.Name, eventStatus);
}
if (resource.GetEventType() == PipelineEventType.ReleaseCompletedApproval)
{
var releaseApprovalModel = resource.BuildReleaseApprovalModel();
eventStatus = $"Release approval {releaseApprovalModel.Approval.Status}";
eventDate = releaseApprovalModel.Approval.ModifiedOn;
baseEventType = BaseEventType.Release;
var environment = service.Environments.FirstOrDefault(x => x.ProjectEnvironment.Name.Equals(releaseApprovalModel.Approval.ReleaseEnvironment.Name, StringComparison.InvariantCultureIgnoreCase));
if (environment.LastEventDate < eventDate)
{
environment.LastStatus = $"Release approval {releaseApprovalModel.Approval.Status}";
environment.LastStatusCode = releaseApprovalModel.Approval.Status.Equals("rejected", StringComparison.InvariantCultureIgnoreCase) ? PipelineReleaseStatus.DeployRejectedApproval.ToString() : PipelineReleaseStatus.DeployAcceptedApproval.ToString();
environment.LastEventDate = eventDate;
}
if (eventDate > service.LasReleaseEventDate)
{
service.PipelineStatus = releaseApprovalModel.Approval.Status.Equals("rejected", StringComparison.InvariantCultureIgnoreCase) ? PipelineStatus.DeployRejectedApproval : PipelineStatus.DeployAcceptedApproval;
service.LastPipelineReleaseStatus = releaseApprovalModel.Approval.Status.Equals("rejected", StringComparison.InvariantCultureIgnoreCase) ? PipelineReleaseStatus.DeployRejectedApproval : PipelineReleaseStatus.DeployAcceptedApproval;
service.LasReleaseEventDate = eventDate;
}
//Delivery
service.UpdateDeliveryReleaseStatus(int.Parse(releaseApprovalModel.VersionId), releaseApprovalModel.VersionName, releaseApprovalModel.Approval.ReleaseEnvironment.Name, eventStatus);
}
if (resource.GetEventType() == PipelineEventType.ReleaseCompleted)
{
var releaseModel = resource.BuildReleaseModel();
eventStatus = releaseModel.Environment.Status.FirstCharToUpper();
eventDate = releaseModel.Deployment.CompletedOn;
baseEventType = BaseEventType.Release;
if (releaseModel.Environment.Status.Equals("Rejected", StringComparison.InvariantCultureIgnoreCase))
{
eventDate = releaseModel.Deployment.LastModifiedOn;
}
var environment = service.Environments.FirstOrDefault(x => x.ProjectEnvironment.Name.Equals(releaseModel.Environment.Name, StringComparison.InvariantCultureIgnoreCase));
if (environment.LastEventDate < eventDate)
{
environment.LastStatus = releaseModel.Environment.Status.FirstCharToUpper();
environment.LastVersionId = releaseModel.Deployment.VersionId;
environment.LastVersionName = releaseModel.Deployment.VersionName;
environment.LastEventDate = eventDate;
}
if (releaseModel.Environment.Status.Equals("Succeeded", StringComparison.InvariantCultureIgnoreCase))
{
environment.LastSuccessVersionId = releaseModel.Deployment.VersionId;
environment.LastSuccessVersionName = releaseModel.Deployment.VersionName;
environment.LastStatusCode = PipelineReleaseStatus.DeploySucceeded.ToString();
}
if (releaseModel.Environment.Status.Equals("Failed", StringComparison.InvariantCultureIgnoreCase) ||
releaseModel.Environment.Status.Equals("Error", StringComparison.InvariantCultureIgnoreCase))
{
environment.LastStatusCode = PipelineReleaseStatus.DeployFailed.ToString();
}
if (releaseModel.Environment.Status.Equals("Canceled", StringComparison.InvariantCultureIgnoreCase))
{
environment.LastStatusCode = PipelineReleaseStatus.DeployCanceled.ToString();
}
if (releaseModel.Environment.Status.Equals("Rejected", StringComparison.InvariantCultureIgnoreCase))
{
environment.LastStatusCode = PipelineReleaseStatus.DeployRejected.ToString();
}
if (eventDate > service.LasReleaseEventDate)
{
if (releaseModel.Environment.Status.Equals("Succeeded", StringComparison.InvariantCultureIgnoreCase))
{
service.PipelineStatus = PipelineStatus.DeploySucceeded;
service.LastPipelineReleaseStatus = PipelineReleaseStatus.DeploySucceeded;
}
if (releaseModel.Environment.Status.Equals("Failed", StringComparison.InvariantCultureIgnoreCase) ||
releaseModel.Environment.Status.Equals("Error", StringComparison.InvariantCultureIgnoreCase))
{
service.PipelineStatus = PipelineStatus.DeployFailed;
service.LastPipelineReleaseStatus = PipelineReleaseStatus.DeployFailed;
}
if (releaseModel.Environment.Status.Equals("Canceled", StringComparison.InvariantCultureIgnoreCase))
{
service.PipelineStatus = PipelineStatus.DeployCanceled;
service.LastPipelineReleaseStatus = PipelineReleaseStatus.DeployCanceled;
}
if (releaseModel.Environment.Status.Equals("Rejected", StringComparison.InvariantCultureIgnoreCase))
{
service.PipelineStatus = PipelineStatus.DeployRejected;
service.LastPipelineReleaseStatus = PipelineReleaseStatus.DeployRejected;
}
service.LasReleaseEventDate = eventDate;
}
//Delivery
service.UpdateDeliveryReleaseStatus(int.Parse(releaseModel.Deployment.VersionId), releaseModel.Deployment.VersionName, releaseModel.Environment.Name, eventStatus);
}
/*SERVICE STATUS###########################################################################################################*/
/*#########################################################################################################################*/
//activate the service when build is failed
if (resource.GetEventType() == PipelineEventType.BuildCompleted &&
(eventStatus.Equals("Failed", StringComparison.InvariantCultureIgnoreCase) ||
eventStatus.Equals("Error", StringComparison.InvariantCultureIgnoreCase) ||
eventStatus.Equals("Canceled", StringComparison.InvariantCultureIgnoreCase)) &&
service.Status == EntityStatus.Preparing)
{
service.Status = EntityStatus.Active;
}
//activate the service when realease is completed (in any event status)
if (resource.GetEventType() == PipelineEventType.ReleaseCompleted && service.Status == EntityStatus.Preparing)
{
service.Status = EntityStatus.Active;
}
service.AddEvent(baseEventType, resource.GetEventType().GetDescription(), resource.Message.Text, eventStatus, JsonConvert.SerializeObject(resource.DetailedMessage), JsonConvert.SerializeObject(resource.DetailedMessage), JsonConvert.SerializeObject(resource.Resource), eventDate);
_organizationRepository.Update(organization);
await _organizationRepository.SaveChanges();
}
public async Task CreateProjectServiceEnvironmentRelease(Guid organizationId, Guid projectId, Guid serviceId, 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;
}
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 create a release.");
return;
}
DomainModels.ProjectServiceEnvironment environment = projectService.GetServiceEnvironment(environmentId);
if (environment == null)
{
await _domainManagerService.AddNotFound($"The environment with id {environmentId} does not exists.");
return;
}
if (environment.Status != DomainModels.EntityStatus.Active)
{
await _domainManagerService.AddConflict($"The environment with id {environmentId} must be in status Active to create a release.");
return;
}
var previousEnvironment = projectService.Environments.FirstOrDefault(x => x.ProjectEnvironment.Rank == ((environment.ProjectEnvironment.Type == EnvironmentType.Root) ? environment.ProjectEnvironment.Rank : environment.ProjectEnvironment.Rank - 1));
if (string.IsNullOrEmpty(previousEnvironment.LastSuccessVersionId))
{
await _domainManagerService.AddConflict($"The project service with id {serviceId} does not have any success deploy in the environment {previousEnvironment.ProjectEnvironment.Name} (This is a condition to create the release).");
return;
}
var environmentsToBeSkippedList = project.Environments.Where(x => x.Rank < environment.ProjectEnvironment.Rank);
var descriptionsToBeSkipped = $"Release created from PipelineSpace.";
if (environmentsToBeSkippedList.Any())
{
descriptionsToBeSkipped = $"{descriptionsToBeSkipped} Detail: {string.Join(", ", environmentsToBeSkippedList.Select(x => $"PS_SKIP_ENVIRONMENT_{x.Name}"))}";
}
CMSPipelineReleaseParamModel releaseBuildOptions = new CMSPipelineReleaseParamModel();
releaseBuildOptions.VSTSAPIVersion = _vstsOptions.Value.ApiVersion;
releaseBuildOptions.VSTSAccountName = project.OrganizationCMS.Type == ConfigurationManagementService.VSTS ? _dataProtectorService.Unprotect(project.OrganizationCMS.AccountName) : _fakeAccountOptions.Value.AccountId;
releaseBuildOptions.VSTSAccessSecret = project.OrganizationCMS.Type == ConfigurationManagementService.VSTS ? _dataProtectorService.Unprotect(project.OrganizationCMS.AccessSecret) : _fakeAccountOptions.Value.AccessSecret;
releaseBuildOptions.VSTSAccountProjectId = project.OrganizationCMS.Type == ConfigurationManagementService.VSTS ? project.Name : project.ProjectVSTSFakeName;
releaseBuildOptions.ProjectName = project.Name;
releaseBuildOptions.ProjectExternalId = project.OrganizationCMS.Type == ConfigurationManagementService.VSTS ? project.ProjectExternalId : project.ProjectVSTSFakeId;
releaseBuildOptions.ReleaseDefinitionId = projectService.ReleaseStageId.Value;
releaseBuildOptions.Alias = projectService.Name;
releaseBuildOptions.VersionId = int.Parse(previousEnvironment.LastSuccessVersionId);
releaseBuildOptions.VersionName = previousEnvironment.LastSuccessVersionName;
releaseBuildOptions.Description = descriptionsToBeSkipped;
await _cmsPipelineService.CreateRelease(releaseBuildOptions);
}
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 <ProjectServiceEnvironmentListRp> GetProjectServiceEnvironments(Guid organizationId, Guid projectId, Guid serviceId)
{
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(null);
}
DomainModels.Project project = user.FindProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return(null);
}
DomainModels.ProjectService projectService = project.GetServiceById(serviceId);
if (projectService == null)
{
await _domainManagerService.AddNotFound($"The project service with id {serviceId} does not exists.");
return(null);
}
ProjectServiceEnvironmentListRp list = new ProjectServiceEnvironmentListRp();
if (project.OrganizationCPS.Type == DomainModels.CloudProviderService.None)
{
return(list);
}
CPSAuthCredentialModel authCredentials = new CPSAuthCredentialModel();
authCredentials.AccessId = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessId);
authCredentials.AccessName = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessName);
authCredentials.AccessSecret = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessSecret);
authCredentials.AccessRegion = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessRegion);
authCredentials.AccessAppId = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessAppId);
authCredentials.AccessAppSecret = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessAppSecret);
authCredentials.AccessDirectory = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessDirectory);
if (projectService.Environments != null)
{
List <ProjectServiceEnvironmentListItemRp> projectServiceEnvironmentList = new List <ProjectServiceEnvironmentListItemRp>();
var environments = projectService.Environments.OrderBy(x => x.ProjectEnvironment.Rank);
foreach (var item in environments)
{
var projectServiceEnvironmentListItem = new ProjectServiceEnvironmentListItemRp();
projectServiceEnvironmentListItem.ProjectServiceEnvironmentId = item.ProjectServiceEnvironmentId;
projectServiceEnvironmentListItem.Name = item.ProjectEnvironment.Name;
projectServiceEnvironmentListItem.Status = item.Status;
projectServiceEnvironmentListItem.Summary = await _cpsQueryService(project.OrganizationCPS.Type).GetEnvironmentSummary(organization.Name, project.Name, projectService.Name, item.ProjectEnvironment.Name, "Root", authCredentials);
projectServiceEnvironmentListItem.Variables = item.Variables.Select(p => new ProjectServiceEnvironmentVariableListItemRp()
{
Name = p.Name,
Value = p.Value
}).ToList();
projectServiceEnvironmentList.Add(projectServiceEnvironmentListItem);
}
list.Items = projectServiceEnvironmentList;
}
return(list);
}
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);
}
public async Task <ProjectServiceSummaryGetRp> GetProjectServiceSummaryById(Guid organizationId, Guid projectId, Guid serviceId)
{
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(null);
}
DomainModels.Project project = user.FindProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return(null);
}
DomainModels.ProjectService service = project.GetServiceById(serviceId);
if (service == null)
{
return(null);
}
ProjectServiceSummaryGetRp serviceSummaryRp = new ProjectServiceSummaryGetRp
{
Name = service.Name,
Description = service.Description,
Status = service.Status,
PipeType = service.PipeType,
PipelineStatus = service.PipelineStatus,
LastPipelineBuildStatus = service.LastPipelineBuildStatus,
LastPipelineReleaseStatus = service.LastPipelineReleaseStatus,
Activities = new ProjectServiceActivityListRp()
{
Items = service.Activities.OrderBy(x => x.CreationDate).Select(x => new ProjectServiceActivityListItemRp()
{
Name = x.Name,
Log = x.Log,
CreationDate = x.CreationDate,
ActivityStatus = x.ActivityStatus
}).ToList()
},
Events = new ProjectServiceEventListRp()
{
Items = service.Events.OrderByDescending(x => x.EventDate).Take(6).Select(x => new ProjectServiceEventListItemRp()
{
EventDescription = x.EventDescription,
EventType = x.EventType,
EventStatus = x.EventStatus,
CreationDate = x.CreationDate,
EventDate = x.EventDate
}).ToList()
}
};
return(serviceSummaryRp);
}
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 <ProjectServiceExternalGetRp> GetProjectServiceExternalById(Guid organizationId, Guid projectId, Guid serviceId)
{
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(null);
}
DomainModels.Project project = organization.GetProjectById(projectId);
if (project == null)
{
await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");
return(null);
}
DomainModels.ProjectService service = project.GetServiceById(serviceId);
if (service == null)
{
return(null);
}
CMSAuthCredentialModel cmsAuthCredential = null;
var serviceExternalName = string.Empty;
var projectExternalId = string.Empty;
//Auth
cmsAuthCredential = this._cmsCredentialService(service.OrganizationCMS.Type).GetToken(
_dataProtectorService.Unprotect(service.OrganizationCMS.AccountId),
_dataProtectorService.Unprotect(service.OrganizationCMS.AccountName),
_dataProtectorService.Unprotect(service.OrganizationCMS.AccessSecret),
_dataProtectorService.Unprotect(service.OrganizationCMS.AccessToken));
switch (service.OrganizationCMS.Type)
{
case ConfigurationManagementService.VSTS:
serviceExternalName = service.ProjectServiceExternalId;
projectExternalId = service.ProjectExternalId;
break;
case ConfigurationManagementService.Bitbucket:
serviceExternalName = service.ProjectServiceExternalId;
projectExternalId = project.OrganizationExternalId;
break;
case ConfigurationManagementService.GitHub:
serviceExternalName = service.ProjectServiceExternalName;
projectExternalId = service.ProjectExternalId;
break;
case ConfigurationManagementService.GitLab:
serviceExternalName = service.ProjectServiceExternalId;
projectExternalId = service.ProjectExternalId;
break;
default:
break;
}
var serviceExternal = await this._cmsQueryService(service.OrganizationCMS.Type).GetRepository(projectExternalId, serviceExternalName, cmsAuthCredential);
return(new ProjectServiceExternalGetRp {
DefaultBranch = serviceExternal.DefaultBranch,
GitUrl = serviceExternal.Link,
SSHUrl = serviceExternal.SSHUrl
});
}