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 CompleteProjectFeature(Guid organizationId, Guid projectId, Guid featureId) { 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"); } ProjectFeature feature = project.GetFeatureById(featureId); if (feature == null) { throw new ApplicationException($"The feature with id {featureId} does not exists"); } feature.Complete(); }
public ProjectService ImportProjectService(Guid organizationId, Guid projectId, Guid organizationCMSId, string agentId, string name, string repositoryName, string description, Guid projectServiceTemplateId, PipeType pipeType, string branchName, string branchUrl, string projectExternaId, string projectExternalName) { 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"); } var newService = ProjectService.Factory.Create(name, repositoryName, description, projectServiceTemplateId, pipeType, projectId, organizationCMSId, project.AgentPoolId, this.Id); newService.IsImported = true; newService.BranchName = branchName; newService.ProjectExternalName = projectExternalName; newService.ProjectExternalId = projectExternaId; newService.ProjectBranchServiceExternalUrl = branchUrl; project.AddService(newService); return(newService); }
public ProjectEnvironment CreateProjectEnvironment(Guid organizationId, Guid projectId, string name, string description, bool requiresApproval, bool autoProvision) { 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"); } //Reorder var productionEnvironment = project.GetProductionEnvironment(); var newEnvironment = ProjectEnvironment.Factory.Create(name, description, EnvironmentType.Plan, requiresApproval, autoProvision, productionEnvironment.Rank, this.Id); project.AddEnvironment(newEnvironment); productionEnvironment.Rank = productionEnvironment.Rank + 1; return(newEnvironment); }
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 void ReactivateProjectEnvironment(Guid organizationId, Guid projectId, Guid environmentId) { 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"); } ProjectEnvironment projectEnvironment = project.GetEnvironmentById(environmentId); if (projectEnvironment == null) { throw new ApplicationException($"The project environment with id {environmentId} does not exists"); } projectEnvironment.Rectivate(); }
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 ProjectFeature CreateProjectFeature(Guid organizationId, Guid projectId, 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"); } var newFeature = ProjectFeature.Factory.Create(name, description, this.Id); ProjectFeatureEnvironment developmentProjectEnvironment = ProjectFeatureEnvironment.Factory.Create(DomainConstants.Environments.Development, "Environment for development and some tests", EnvironmentType.Root, false, 1, this.Id); developmentProjectEnvironment.Activate(); newFeature.AddEnvironment(developmentProjectEnvironment); project.AddFeature(newFeature); return(newFeature); }
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 int GetTotalFeaturesByProject(Guid organizationId, Guid projectId) { 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"); } return(project.Features.Count()); }
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 <ProjectServiceListRp> GetProjectServices(Guid organizationId, Guid projectId) { 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); } ProjectServiceListRp list = new ProjectServiceListRp(); if (project.Services != null) { list.Items = project.Services.Select(x => new ProjectServiceListItemRp() { ProjectServiceId = x.ProjectServiceId, Name = x.Name, Description = x.Description, Template = x.ProjectServiceTemplate.Name, Status = x.Status, PipelineStatus = x.PipelineStatus, CreationDate = x.CreationDate, PipeType = x.ProjectServiceTemplate.PipeType }).ToList(); } return(list); }
public ProjectService CreateProjectService(Guid organizationId, Guid projectId, Guid organizationCMSId, string agentPoolId, string name, string repositoryName, string description, Guid projectServiceTemplateId, PipeType pipeType) { 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"); } var newService = ProjectService.Factory.Create(name, repositoryName, description, projectServiceTemplateId, pipeType, projectId, organizationCMSId, agentPoolId, this.Id); project.AddService(newService); return(newService); }
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 }); }
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 CreateProjectFeatureServiceEvent(Guid organizationId, Guid projectId, Guid featureId, Guid serviceId, ProjectFeatureServiceEventPostRp 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.ProjectFeature feature = project.GetFeatureById(featureId); if (feature == null) { await _domainManagerService.AddNotFound($"The project feature with id {featureId} does not exists."); return; } DomainModels.ProjectFeatureService featureService = feature.GetFeatureServiceById(serviceId); if (featureService == null) { await _domainManagerService.AddNotFound($"The project feature with id {featureId} does not exists."); return; } /*PIPELINE STATUS###########################################################################################################*/ /*##########################################################################################################################*/ //update pipeline status when build string eventStatus = string.Empty; DateTime eventDate = DateTime.UtcNow; BaseEventType baseEventType = BaseEventType.Build; //update pipeline status when build if (resource.GetEventType() == PipelineEventType.BuildStarted) { eventStatus = "Queued"; baseEventType = BaseEventType.Build; if (eventDate > featureService.LastBuildEventDate) { featureService.PipelineStatus = PipelineStatus.Building; featureService.LastPipelineBuildStatus = PipelineBuildStatus.Building; featureService.LastBuildEventDate = eventDate; } } if (resource.GetEventType() == PipelineEventType.BuildCompleted) { var buildModel = resource.BuildBuildModel(); eventStatus = buildModel.Status.FirstCharToUpper(); eventDate = buildModel.FinishTime; baseEventType = BaseEventType.Build; featureService.LastBuildVersionId = buildModel.Id.ToString(); featureService.LastBuildVersionName = buildModel.BuildNumber; if (eventDate > featureService.LastBuildEventDate) { if (buildModel.Status.Equals("Succeeded", StringComparison.InvariantCultureIgnoreCase)) { featureService.PipelineStatus = PipelineStatus.BuildSucceeded; featureService.LastPipelineBuildStatus = PipelineBuildStatus.BuildSucceeded; featureService.LastBuildSuccessVersionId = buildModel.Id.ToString(); featureService.LastBuildSuccessVersionName = buildModel.BuildNumber; } if (buildModel.Status.Equals("Failed", StringComparison.InvariantCultureIgnoreCase) || buildModel.Status.Equals("Error", StringComparison.InvariantCultureIgnoreCase)) { featureService.PipelineStatus = PipelineStatus.BuildFailed; featureService.LastPipelineBuildStatus = PipelineBuildStatus.BuildFailed; } if (buildModel.Status.Equals("Canceled", StringComparison.InvariantCultureIgnoreCase)) { featureService.PipelineStatus = PipelineStatus.BuildCanceled; featureService.LastPipelineBuildStatus = PipelineBuildStatus.BuildCanceled; } featureService.LastBuildEventDate = eventDate; } //Delivery featureService.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 = featureService.Environments.FirstOrDefault(x => x.ProjectFeatureEnvironment.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 > featureService.LasReleaseEventDate) { featureService.PipelineStatus = PipelineStatus.Deploying; featureService.LastPipelineReleaseStatus = PipelineReleaseStatus.Deploying; featureService.LasReleaseEventDate = eventDate; } //Delivery featureService.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 = featureService.Environments.FirstOrDefault(x => x.ProjectFeatureEnvironment.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 > featureService.LasReleaseEventDate) { featureService.PipelineStatus = PipelineStatus.DeployPendingApproval; featureService.LastPipelineReleaseStatus = PipelineReleaseStatus.DeployPendingApproval; featureService.LasReleaseEventDate = eventDate; } //Delivery featureService.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.CreatedOn; baseEventType = BaseEventType.Release; var environment = featureService.Environments.FirstOrDefault(x => x.ProjectFeatureEnvironment.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 > featureService.LasReleaseEventDate) { featureService.PipelineStatus = releaseApprovalModel.Approval.Status.Equals("rejected", StringComparison.InvariantCultureIgnoreCase) ? PipelineStatus.DeployRejectedApproval : PipelineStatus.DeployAcceptedApproval; featureService.LastPipelineReleaseStatus = releaseApprovalModel.Approval.Status.Equals("rejected", StringComparison.InvariantCultureIgnoreCase) ? PipelineReleaseStatus.DeployRejectedApproval : PipelineReleaseStatus.DeployAcceptedApproval; featureService.LasReleaseEventDate = eventDate; } //Delivery featureService.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 = featureService.Environments.FirstOrDefault(x => x.ProjectFeatureEnvironment.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 > featureService.LasReleaseEventDate) { if (releaseModel.Environment.Status.Equals("Succeeded", StringComparison.InvariantCultureIgnoreCase)) { featureService.PipelineStatus = PipelineStatus.DeploySucceeded; featureService.LastPipelineReleaseStatus = PipelineReleaseStatus.DeploySucceeded; } if (releaseModel.Environment.Status.Equals("Failed", StringComparison.InvariantCultureIgnoreCase) || releaseModel.Environment.Status.Equals("Error", StringComparison.InvariantCultureIgnoreCase)) { featureService.PipelineStatus = PipelineStatus.DeployFailed; featureService.LastPipelineReleaseStatus = PipelineReleaseStatus.DeployFailed; } if (releaseModel.Environment.Status.Equals("Canceled", StringComparison.InvariantCultureIgnoreCase)) { featureService.PipelineStatus = PipelineStatus.DeployCanceled; featureService.LastPipelineReleaseStatus = PipelineReleaseStatus.DeployCanceled; } if (releaseModel.Environment.Status.Equals("Rejected", StringComparison.InvariantCultureIgnoreCase)) { featureService.PipelineStatus = PipelineStatus.DeployRejected; featureService.LastPipelineReleaseStatus = PipelineReleaseStatus.DeployRejected; } featureService.LasReleaseEventDate = eventDate; } //Delivery featureService.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)) && featureService.Status == EntityStatus.Preparing) { featureService.Status = EntityStatus.Active; } //activate the service when realease is completed (in any event status) if (resource.GetEventType() == PipelineEventType.ReleaseCompleted && featureService.Status == EntityStatus.Preparing) { featureService.Status = EntityStatus.Active; } featureService.AddEvent(baseEventType, resource.GetEventType().GetDescription(), resource.Message.Text, eventStatus, JsonConvert.SerializeObject(resource.DetailedMessage), JsonConvert.SerializeObject(resource.DetailedMessage), JsonConvert.SerializeObject(resource.Resource), eventDate); //check if any feature service is in preparing status yet var preparingServices = feature.GetPreparingServices(); if (!preparingServices.Any()) { feature.Status = EntityStatus.Active; } _organizationRepository.Update(organization); await _organizationRepository.SaveChanges(); }