ee/app/assets/javascripts/security_configuration/dast_profiles/dast_site_profiles/constants.js

@@ -15,21 +15,19 @@ export const SCAN_METHODS = {
   HAR: {
     text: __('HTTP Archive (HAR)'),
     value: 'HAR',
-    inputLabel: __('HAR file path or URL'),
-    placeholder: s__(
-      'DastProfiles|folder/dast_example.har or https://example.com/dast_example.har',
-    ),
+    inputLabel: __('HAR file URL'),
+    placeholder: s__('DastProfiles|https://example.com/dast_example.har'),
   },
   OPENAPI: {
     text: __('OpenAPI'),
     value: 'OPENAPI',
-    inputLabel: __('OpenAPI Specification file path or URL'),
-    placeholder: s__('DastProfiles|folder/openapi.json or https://example.com/openapi.json'),
+    inputLabel: __('OpenAPI Specification file URL'),
+    placeholder: s__('DastProfiles|https://example.com/openapi.json'),
   },
   POSTMAN_COLLECTION: {
     text: __('Postman collection'),
     value: 'POSTMAN_COLLECTION',
-    inputLabel: __('Postman collection file path or URL'),
-    placeholder: s__('DastProfiles|folder/example.postman_collection.json or https://example.com/'),
+    inputLabel: __('Postman collection file URL'),
+    placeholder: s__('DastProfiles|https://example.com/postman_collection.json'),
   },
 };

ee/app/assets/javascripts/trials/country_select.js

-import $ from 'jquery';
-import createFlash from '~/flash';
-import axios from '~/lib/utils/axios_utils';
-import { __ } from '~/locale';
-
-const selectElement = document.getElementById('country_select');
-
-if (selectElement?.dataset) {
-  const { countriesEndPoint, selectedOption } = selectElement.dataset;
-
-  axios
-    .get(countriesEndPoint)
-    .then(({ data }) => {
-      // fill #country_select element with array of <option>s
-      data.forEach(([name, code]) => {
-        const option = document.createElement('option');
-        option.value = code;
-        option.text = name;
-
-        selectElement.appendChild(option);
-      });
-      $(selectElement).val(selectedOption).trigger('change.select2');
-    })
-    .catch(() =>
-      createFlash({
-        message: __('Error loading countries data.'),
-      }),
-    );
-}

ee/app/controllers/concerns/registrations/apply_trial.rb

-# frozen_string_literal: true
-
-module Registrations::ApplyTrial
-  extend ActiveSupport::Concern
-
-  included do
-    private
-
-    def apply_trial
-      apply_trial_params = {
-        uid: current_user.id,
-        trial_user: params.permit(:glm_source, :glm_content).merge({
-                                                                     namespace_id: @group.id,
-                                                                     gitlab_com_trial: true,
-                                                                     sync_to_gl: true
-                                                                   })
-      }
-
-      result = GitlabSubscriptions::ApplyTrialService.new.execute(apply_trial_params)
-      flash.now[:alert] = result&.dig(:errors) unless result&.dig(:success)
-
-      result&.dig(:success)
-    end
-  end
-end

ee/app/controllers/concerns/registrations/create_group.rb

-# frozen_string_literal: true
-
-module Registrations::CreateGroup
-  extend ActiveSupport::Concern
-
-  included do
-    before_action :check_if_gl_com_or_dev
-    before_action :authorize_create_group!, only: :new
-
-    protected
-
-    def show_confirm_warning?
-      false
-    end
-
-    private
-
-    def authorize_create_group!
-      access_denied! unless can?(current_user, :create_group)
-    end
-
-    def group_params
-      params.require(:group).permit(
-        :name,
-        :path,
-        :visibility_level
-      ).merge(
-        create_event: true,
-        setup_for_company: current_user.setup_for_company
-      )
-    end
-  end
-end

ee/app/controllers/concerns/registrations/create_project.rb

-# frozen_string_literal: true
-
-module Registrations::CreateProject
-  extend ActiveSupport::Concern
-  include LearnGitlabHelper
-
-  LEARN_GITLAB_ULTIMATE_TEMPLATE = 'learn_gitlab_ultimate.tar.gz'
-
-  included do
-    private
-
-    def learn_gitlab_template_path
-      Rails.root.join('vendor', 'project_templates', LEARN_GITLAB_ULTIMATE_TEMPLATE)
-    end
-
-    def create_learn_gitlab_project(parent_project_namespace_id)
-      ::Onboarding::CreateLearnGitlabWorker.perform_async(learn_gitlab_template_path,
-                                                          learn_gitlab_project_name,
-                                                          parent_project_namespace_id,
-                                                          current_user.id)
-    end
-
-    def learn_gitlab_project_name
-      helpers.in_trial_onboarding_flow? ? LearnGitlab::Project::PROJECT_NAME_ULTIMATE_TRIAL : LearnGitlab::Project::PROJECT_NAME
-    end
-
-    def project_params
-      params.require(:project).permit(project_params_attributes)
-    end
-
-    def project_params_attributes
-      [
-        :namespace_id,
-        :name,
-        :path,
-        :visibility_level
-      ]
-    end
-  end
-end

ee/app/controllers/ee/registrations/welcome_controller.rb

@@ -19,10 +19,6 @@ module WelcomeController
                         :trial_onboarding_board
                       ]
 
-        before_action only: :show do
-          publish_combined_registration_experiment
-        end
-
         before_action only: [:trial_getting_started] do
           push_frontend_feature_flag(:gitlab_gtm_datalayer, type: :ops)
         end
@@ -90,14 +86,6 @@ def learn_gitlab_project
         end
       end
 
-      def publish_combined_registration_experiment
-        combined_registration_experiment.publish if show_signup_onboarding?
-      end
-
-      def combined_registration_experiment
-        experiment(:combined_registration, user: current_user)
-      end
-
       def passed_through_params
         update_params.slice(:role, :registration_objective).merge(params.permit(:jobs_to_be_done_other))
       end
@@ -110,7 +98,7 @@ def update_success_path
           if show_company_form?
             new_users_sign_up_company_path(passed_through_params)
           else
-            experiment(:combined_registration, user: current_user).redirect_path
+            new_users_sign_up_groups_project_path
           end
         end
       end

ee/app/controllers/registrations/groups_controller.rb

-# frozen_string_literal: true
-
-module Registrations
-  class GroupsController < ApplicationController
-    include Registrations::CreateGroup
-    include Registrations::ApplyTrial
-    include ::Gitlab::Utils::StrongMemoize
-    include OneTrustCSP
-    include GoogleAnalyticsCSP
-
-    layout 'minimal'
-
-    feature_category :onboarding
-
-    def new
-      @group = Group.new(visibility_level: helpers.default_group_visibility)
-      experiment(:combined_registration, user: current_user).track(:view_new_group_action)
-      push_frontend_feature_flag(:gitlab_gtm_datalayer, type: :ops)
-    end
-
-    def create
-      @group = Groups::CreateService.new(current_user, group_params).execute
-
-      if @group.persisted?
-        experiment(:combined_registration, user: current_user).track(:create_group, namespace: @group)
-
-        create_successful_flow
-      else
-        render action: :new
-      end
-    end
-
-    private
-
-    def create_successful_flow
-      if helpers.in_trial_onboarding_flow?
-        apply_trial_for_trial_onboarding_flow
-      else
-        registration_onboarding_flow
-      end
-    end
-
-    def apply_trial_for_trial_onboarding_flow
-      if apply_trial
-        redirect_to new_users_sign_up_project_path(namespace_id: @group.id, trial: helpers.in_trial_during_signup_flow?, trial_onboarding_flow: true)
-      else
-        render action: :new
-      end
-    end
-
-    def registration_onboarding_flow
-      if helpers.in_trial_during_signup_flow?
-        create_lead_and_apply_trial_flow
-      else
-        redirect_to new_users_sign_up_project_path(namespace_id: @group.id, trial: false)
-      end
-    end
-
-    def create_lead_and_apply_trial_flow
-      if create_lead && apply_trial
-        redirect_to new_users_sign_up_project_path(namespace_id: @group.id, trial: true)
-      else
-        render action: :new
-      end
-    end
-
-    def create_lead
-      trial_params = {
-        trial_user: params.permit(
-          :company_name,
-          :company_size,
-          :phone_number,
-          :country
-        ).merge(
-          work_email: current_user.email,
-          first_name: current_user.first_name,
-          last_name: current_user.last_name,
-          uid: current_user.id,
-          setup_for_company: current_user.setup_for_company,
-          skip_email_confirmation: true,
-          gitlab_com_trial: true,
-          provider: 'gitlab',
-          newsletter_segment: current_user.email_opted_in
-        )
-      }
-      result = GitlabSubscriptions::CreateLeadService.new.execute(trial_params)
-      flash[:alert] = result&.dig(:errors) unless result&.dig(:success)
-
-      result&.dig(:success)
-    end
-  end
-end

ee/app/controllers/registrations/groups_projects_controller.rb

@@ -2,15 +2,18 @@
 
 module Registrations
   class GroupsProjectsController < ApplicationController
-    include Registrations::CreateProject
-    include Registrations::CreateGroup
-    include Registrations::ApplyTrial
+    include LearnGitlabHelper
     include OneTrustCSP
     include GoogleAnalyticsCSP
 
     skip_before_action :require_verification, only: :new
+    skip_before_action :set_confirm_warning
+    before_action :check_if_gl_com_or_dev
+    before_action :authorize_create_group!, only: :new
     before_action :set_requires_verification, only: :new, if: -> { helpers.require_verification_experiment.candidate? }
-    before_action :require_verification, only: [:create, :import], if: -> { current_user.requires_credit_card_verification }
+    before_action :require_verification,
+                  only: [:create, :import],
+                  if: -> { current_user.requires_credit_card_verification }
     before_action only: [:new] do
       push_frontend_feature_flag(:gitlab_gtm_datalayer, type: :ops)
     end
@@ -25,7 +28,7 @@ def new
       @group = Group.new(visibility_level: helpers.default_group_visibility)
       @project = Project.new(namespace: @group)
 
-      combined_registration_experiment.track(:view_new_group_action)
+      Gitlab::Tracking.event(self.class.name, 'view_new_group_action', user: current_user)
     end
 
     def create
@@ -38,7 +41,7 @@ def create
       if @group.persisted?
         if @group.previously_new_record?
           # project failed validation previously, but group was created or coming from trial creation
-          combined_registration_experiment.track(:create_group, namespace: @group)
+          Gitlab::Tracking.event(self.class.name, 'create_group', namespace: @group, user: current_user)
           helpers.require_verification_experiment.record_conversion(@group)
 
           unless apply_trial_when_in_trial_flow
@@ -50,7 +53,7 @@ def create
 
         @project = ::Projects::CreateService.new(current_user, create_project_params).execute
         if @project.saved?
-          combined_registration_experiment.track(:create_project, namespace: @project.namespace)
+          Gitlab::Tracking.event(self.class.name, 'create_project', namespace: @project.namespace, user: current_user)
 
           create_learn_gitlab_project(@project.namespace_id)
 
@@ -77,7 +80,7 @@ def create
     def import
       @group = Groups::CreateService.new(current_user, modified_group_params).execute
       if @group.persisted? && apply_trial_when_in_trial_flow
-        combined_registration_experiment.track(:create_group, namespace: @group)
+        Gitlab::Tracking.event(self.class.name, 'create_group_import', namespace: @group, user: current_user)
         helpers.require_verification_experiment.record_conversion(@group)
 
         import_url = URI.join(root_url, params[:import_url], "?namespace_id=#{@group.id}").to_s
@@ -100,8 +103,8 @@ def exit
 
     private
 
-    def combined_registration_experiment
-      @combined_registration_experiment ||= experiment(:combined_registration, user: current_user)
+    def authorize_create_group!
+      access_denied! unless can?(current_user, :create_group)
     end
 
     def create_project_params
@@ -122,6 +125,17 @@ def modified_group_params
       modifed_group_params
     end
 
+    def group_params
+      params.require(:group).permit(
+        :name,
+        :path,
+        :visibility_level
+      ).merge(
+        create_event: true,
+        setup_for_company: current_user.setup_for_company
+      )
+    end
+
     def offer_trial?
       current_user.setup_for_company && !helpers.in_trial_onboarding_flow? && !params[:skip_trial].present?
     end
@@ -129,5 +143,51 @@ def offer_trial?
     def apply_trial_when_in_trial_flow
       !helpers.in_trial_onboarding_flow? || apply_trial
     end
+
+    def apply_trial
+      apply_trial_params = {
+        uid: current_user.id,
+        trial_user: params.permit(:glm_source, :glm_content).merge({
+                                                                     namespace_id: @group.id,
+                                                                     gitlab_com_trial: true,
+                                                                     sync_to_gl: true
+                                                                   })
+      }
+
+      result = GitlabSubscriptions::ApplyTrialService.new.execute(apply_trial_params)
+      flash.now[:alert] = result&.dig(:errors) unless result&.dig(:success)
+
+      result&.dig(:success)
+    end
+
+    LEARN_GITLAB_ULTIMATE_TEMPLATE = 'learn_gitlab_ultimate.tar.gz'
+
+    def learn_gitlab_template_path
+      Rails.root.join('vendor', 'project_templates', LEARN_GITLAB_ULTIMATE_TEMPLATE)
+    end
+
+    def create_learn_gitlab_project(parent_project_namespace_id)
+      ::Onboarding::CreateLearnGitlabWorker.perform_async(learn_gitlab_template_path, # rubocop:disable CodeReuse/Worker
+                                                          learn_gitlab_project_name,
+                                                          parent_project_namespace_id,
+                                                          current_user.id)
+    end
+
+    def learn_gitlab_project_name
+      if helpers.in_trial_onboarding_flow?
+        LearnGitlab::Project::PROJECT_NAME_ULTIMATE_TRIAL
+      else
+        LearnGitlab::Project::PROJECT_NAME
+      end
+    end
+
+    def project_params_attributes
+      [
+        :namespace_id,
+        :name,
+        :path,
+        :visibility_level
+      ]
+    end
   end
 end

ee/app/controllers/registrations/projects_controller.rb

-# frozen_string_literal: true
-
-module Registrations
-  class ProjectsController < ApplicationController
-    include Registrations::CreateProject
-    include OneTrustCSP
-    include GoogleAnalyticsCSP
-
-    layout 'minimal'
-
-    before_action :check_if_gl_com_or_dev
-
-    before_action only: [:new] do
-      set_namespace
-      authorize_create_project!
-      push_frontend_feature_flag(:gitlab_gtm_datalayer, type: :ops)
-    end
-
-    feature_category :onboarding
-
-    def new
-      @project = Project.new(namespace: @namespace)
-    end
-
-    def create
-      @project = ::Projects::CreateService.new(current_user, project_params).execute
-
-      if @project.saved?
-        experiment(:combined_registration, user: current_user).track(:create_project, namespace: @project.namespace)
-
-        @learn_gitlab_project = create_learn_gitlab_project
-
-        if helpers.registration_verification_enabled?
-          redirect_to new_users_sign_up_verification_path(url_params)
-        elsif helpers.in_trial_onboarding_flow?
-          redirect_to trial_getting_started_users_sign_up_welcome_path(url_params)
-        else
-          redirect_to continuous_onboarding_getting_started_users_sign_up_welcome_path(url_params)
-        end
-      else
-        render :new
-      end
-    end
-
-    private
-
-    def authorize_create_project!
-      access_denied! unless can?(current_user, :create_projects, @namespace)
-    end
-
-    def set_namespace
-      @namespace = Namespace.find_by_id(params[:namespace_id])
-    end
-
-    def create_learn_gitlab_project
-      File.open(learn_gitlab_template_path) do |archive|
-        ::Projects::GitlabProjectsImportService.new(
-          current_user,
-          namespace_id: @project.namespace_id,
-          file: archive,
-          name: learn_gitlab_project_name
-        ).execute
-      end
-    end
-
-    def url_params
-      if helpers.in_trial_onboarding_flow?
-        { learn_gitlab_project_id: @learn_gitlab_project.id }
-      else
-        { project_id: @project.id }
-      end
-    end
-  end
-end
-
-Registrations::ProjectsController.prepend_mod

ee/app/controllers/trials_controller.rb

@@ -88,8 +88,7 @@ def show_confirm_warning?
   private
 
   def stored_location_or_provided_path(path)
-    if current_user.setup_for_company &&
-        experiment(:combined_registration, user: current_user).assigned.name == 'candidate'
+    if current_user.setup_for_company
       stored_location_for(:user) || path
     else
       path
@@ -225,7 +224,7 @@ def apply_trial_and_redirect
     @result = GitlabSubscriptions::ApplyTrialService.new.execute(apply_trial_params)
 
     if @result&.dig(:success)
-      experiment(:combined_registration, user: current_user).track(:create_trial)
+      Gitlab::Tracking.event(self.class.name, 'create_trial', namespace: @namespace, user: current_user)
 
       if discover_group_security_flow?
         redirect_to group_security_dashboard_url(@namespace, { trial: true })

ee/app/finders/ee/issues_finder.rb

@@ -25,7 +25,8 @@ def filter_items(items)
       issues = by_weight(super)
       issues = by_epic(issues)
       issues = by_iteration(issues)
-      by_iteration_cadence(issues)
+      issues = by_iteration_cadence(issues)
+      by_health_status(issues)
     end
 
     private
@@ -78,6 +79,12 @@ def by_iteration_cadence(items)
       items.in_iteration_cadences(params.iteration_cadence_id)
     end
 
+    def by_health_status(items)
+      return items unless params.by_health_status?
+
+      items.with_health_status(params[:health_status])
+    end
+
     override :filter_negated_items
     def filter_negated_items(items)
       items = by_negated_epic(items)

ee/app/finders/ee/issues_finder/params.rb

@@ -65,6 +65,10 @@ def filter_by_current_iteration?
       def filter_by_iteration_title?
         params[:iteration_title].present?
       end
+
+      def by_health_status?
+        params[:health_status].present?
+      end
     end
   end
 end

ee/app/graphql/ee/resolvers/base_issues_resolver.rb

@@ -22,6 +22,9 @@ module BaseIssuesResolver
         argument :weight, GraphQL::Types::String,
                  required: false,
                  description: 'Weight applied to the issue, "none" and "any" values are supported.'
+        argument :health_status, ::Types::HealthStatusEnum,
+                 required: false,
+                 description: 'Health status of the issue.'
       end
 
       override :resolve_with_lookahead

ee/app/graphql/ee/types/issue_type.rb

@@ -8,6 +8,12 @@ module IssueType
       prepended do
         field :epic, ::Types::EpicType, null: true, description: 'Epic to which this issue belongs.'
 
+        field :has_epic, GraphQL::Types::Boolean,
+          null: false,
+          description: "Indicates if the issue belongs to an epic.
+            Can return true and not show an associated epic when the user has no access to the epic.",
+          method: :has_epic?
+
         field :iteration, ::Types::IterationType, null: true, description: 'Iteration of the issue.'
 
         field :weight, GraphQL::Types::Int, null: true, description: 'Weight of the issue.'

ee/app/graphql/ee/types/mutation_type.rb

@@ -30,6 +30,7 @@ module MutationType
         mount_mutation ::Mutations::RequirementsManagement::CreateRequirement
         mount_mutation ::Mutations::RequirementsManagement::ExportRequirements
         mount_mutation ::Mutations::RequirementsManagement::UpdateRequirement
+        mount_mutation ::Mutations::Security::Finding::CreateIssue
         mount_mutation ::Mutations::Vulnerabilities::Create
         mount_mutation ::Mutations::Vulnerabilities::Dismiss
         mount_mutation ::Mutations::Vulnerabilities::Resolve
@@ -97,7 +98,6 @@ module MutationType
         mount_mutation ::Mutations::AuditEvents::Streaming::Headers::Destroy
         mount_mutation ::Mutations::AuditEvents::Streaming::Headers::Create
         mount_mutation ::Mutations::AuditEvents::Streaming::Headers::Update
-        mount_mutation ::Mutations::SecurityFinding::CreateIssue
 
         prepend(Types::DeprecatedMutations)
       end

ee/app/graphql/mutations/security/finding/create_issue.rb

+# frozen_string_literal: true
+
+module Mutations
+  module Security
+    module Finding
+      class CreateIssue < BaseMutation
+        graphql_name 'SecurityFindingCreateIssue'
+
+        authorize :admin_vulnerability
+
+        field :issue, Types::IssueType,
+              null: true,
+              description: 'Issue created after mutation.'
+
+        argument :uuid,
+                GraphQL::Types::String,
+                required: true,
+                description: 'UUID of the security finding to be used to create an issue.'
+
+        argument :project, ::Types::GlobalIDType[::Project],
+                required: true,
+                description: 'ID of the project to attach the issue to.'
+
+        def resolve(uuid:, project:)
+          project = authorized_find!(id: project)
+          unless ::Feature.enabled?(:deprecate_vulnerabilities_feedback, project)
+            return { errors: ['Feature flag disabled'] }
+          end
+
+          params = { security_finding_uuid: uuid }
+          issue_response = ::Vulnerabilities::SecurityFinding::CreateIssueService.new(project: project,
+                                                                                      current_user: current_user,
+                                                                                      params: params).execute
+
+          return { errors: [issue_response[:message]] } if issue_response.error?
+
+          { errors: [], issue: issue_response[:issue] }
+        end
+
+        private
+
+        def find_object(id:)
+          GitlabSchema.find_by_gid(id)
+        end
+      end
+    end
+  end
+end

ee/app/graphql/mutations/security_finding/create_issue.rb

-# frozen_string_literal: true
-
-module Mutations
-  module SecurityFinding
-    class CreateIssue < BaseMutation
-      graphql_name 'SecurityFindingCreateIssue'
-
-      authorize :admin_vulnerability
-
-      field :issue, Types::IssueType,
-            null: true,
-            description: 'Issue created after mutation.'
-
-      argument :uuid,
-               GraphQL::Types::String,
-               required: true,
-               description: 'UUID of the security finding to be used to create an issue.'
-
-      argument :project, ::Types::GlobalIDType[::Project],
-               required: true,
-               description: 'ID of the project to attach the issue to.'
-
-      def resolve(uuid:, project:)
-        project = authorized_find!(id: project)
-        unless ::Feature.enabled?(:deprecate_vulnerabilities_feedback, project)
-          return { errors: ['Feature flag disabled'] }
-        end
-
-        params = { security_finding_uuid: uuid }
-        issue_response = ::Vulnerabilities::SecurityFinding::CreateIssueService.new(project: project,
-                                                                                    current_user: current_user,
-                                                                                    params: params).execute
-
-        return { errors: [issue_response[:message]] } if issue_response.error?
-
-        { errors: [], issue: issue_response[:issue] }
-      end
-
-      private
-
-      def find_object(id:)
-        GitlabSchema.find_by_gid(id)
-      end
-    end
-  end
-end

ee/app/helpers/ee/welcome_helper.rb

@@ -16,14 +16,6 @@ def in_trial_onboarding_flow?
       params[:trial_onboarding_flow] == 'true'
     end
 
-    def show_trial_during_signup?
-      current_user.setup_for_company
-    end
-
-    def in_trial_during_signup_flow?
-      params[:trial] == 'true'
-    end
-
     def in_oauth_flow?
       redirect_path&.starts_with?(oauth_authorization_path)
     end

ee/app/models/ee/issue.rb

@@ -82,7 +82,8 @@ module Issue
         .public_only
       end
       scope :counts_by_health_status, -> { reorder(nil).group(:health_status).count }
-      scope :with_health_status, -> { where.not(health_status: nil) }
+      scope :with_health_status, ->(status) { where(health_status: status) }
+      scope :with_any_health_status, -> { where.not(health_status: nil) }
       scope :distinct_epic_ids, -> do
         epic_ids = except(:order, :select).joins(:epic_issue).reselect('epic_issues.epic_id').distinct
         epic_ids = epic_ids.group('epic_issues.epic_id') if epic_ids.group_values.present?
@@ -318,6 +319,10 @@ def update_upvotes_count
       super
     end
 
+    def has_epic?
+      epic_issue.present?
+    end
+
     private
 
     def blocking_issues_ids

ee/app/services/epics/descendant_count_service.rb

@@ -61,7 +61,7 @@ def issue_health_statuses
       strong_memoize(:issue_health_statuses) do
         Issue.in_epics(accessible_epics)
           .opened
-          .with_health_status
+          .with_any_health_status
           .counts_by_health_status
       end
     end