public async Task DeleteProjectFeature(Guid organizationId, Guid projectId, Guid featureId)
        {
            string loggedUserId = _identityService.GetUserId();

            DomainModels.User user = await _userRepository.GetUser(loggedUserId);

            DomainModels.Organization organization = user.FindOrganizationById(organizationId);
            if (organization == null)
            {
                await _domainManagerService.AddNotFound($"The organzation with id {organizationId} does not exists.");

                return;
            }

            DomainModels.Project project = user.FindProjectById(projectId);
            if (project == null)
            {
                await _domainManagerService.AddNotFound($"The project with id {projectId} does not exists.");

                return;
            }

            DomainModels.PipelineRole role = user.GetRoleInProject(projectId);
            if (role != DomainModels.PipelineRole.ProjectAdmin)
            {
                await _domainManagerService.AddForbidden($"You are not authorized to delete 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 delete the feature.");

                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 be deleted.");

                return;
            }

            //services asociated (TODO: services on demand)
            List <ProjectFeatureServiceDeletedEvent> projectFeatureServiceDeletedEventList = new List <ProjectFeatureServiceDeletedEvent>();

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

                projectFeatureServiceDeletedEventList.Add(new ProjectFeatureServiceDeletedEvent(_correlationId)
                {
                    ServiceId                             = item.ProjectServiceId,
                    ServiceExternalId                     = projectService.ProjectServiceExternalId,
                    ServiceExternalUrl                    = projectService.ProjectServiceExternalUrl,
                    ServiceName                           = projectService.Name,
                    ServiceTemplateUrl                    = projectService.ProjectServiceTemplate.Url,
                    CommitStageId                         = item.CommitStageId,
                    ReleaseStageId                        = item.ReleaseStageId,
                    CommitServiceHookId                   = item.CommitServiceHookId,
                    ReleaseServiceHookId                  = item.ReleaseServiceHookId,
                    CodeServiceHookId                     = item.CodeServiceHookId,
                    ReleaseStartedServiceHookId           = item.ReleaseStartedServiceHookId,
                    ReleasePendingApprovalServiceHookId   = item.ReleasePendingApprovalServiceHookId,
                    ReleaseCompletedApprovalServiceHookId = item.ReleaseCompletedApprovalServiceHookId,
                    OrganizationId                        = organization.OrganizationId,
                    OrganizationName                      = organization.Name,
                    ProjectId                             = project.ProjectId,
                    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),
                    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),
                    CPSAccessAppId     = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessAppId),
                    CPSAccessAppSecret = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessAppSecret),
                    CPSAccessDirectory = _dataProtectorService.Unprotect(project.OrganizationCPS.AccessDirectory)
                });
            }

            user.DeleteProjectFeature(organizationId, projectId, featureId);

            _userRepository.Update(user);

            await _userRepository.SaveChanges();

            foreach (var item in projectFeatureServiceDeletedEventList)
            {
                await _eventBusService.Publish(queueName : "ProjectFeatureServiceDeletedEvent", @event : item);
            }
        }