898 lines
30 KiB
Ruby
898 lines
30 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
module ProjectsHelper
|
|
include Gitlab::Utils::StrongMemoize
|
|
include CompareHelper
|
|
include Gitlab::Allowable
|
|
|
|
def project_incident_management_setting
|
|
@project_incident_management_setting ||= @project.incident_management_setting ||
|
|
@project.build_incident_management_setting
|
|
end
|
|
|
|
def link_to_project(project)
|
|
link_to namespace_project_path(namespace_id: project.namespace, id: project), title: h(project.name), class: 'gl-link' do
|
|
title = content_tag(:span, project.name, class: 'project-name')
|
|
|
|
if project.namespace
|
|
namespace = content_tag(:span, "#{project.namespace.human_name} / ", class: 'namespace-name')
|
|
title = namespace + title
|
|
end
|
|
|
|
title
|
|
end
|
|
end
|
|
|
|
def link_to_member_avatar(author, opts = {})
|
|
default_opts = { size: 16 }
|
|
opts = default_opts.merge(opts)
|
|
|
|
classes = %W[avatar avatar-inline s#{opts[:size]}]
|
|
classes << opts[:avatar_class] if opts[:avatar_class]
|
|
|
|
avatar = avatar_icon_for_user(author, opts[:size])
|
|
|
|
image_tag(avatar, width: opts[:size], class: classes, alt: '')
|
|
end
|
|
|
|
def author_content_tag(author, opts = {})
|
|
default_opts = { author_class: 'author', tooltip: false, by_username: false }
|
|
opts = default_opts.merge(opts)
|
|
|
|
has_tooltip = !opts[:by_username] && opts[:tooltip]
|
|
|
|
username = opts[:by_username] ? author.to_reference : author.name
|
|
name_tag_options = { class: [opts[:author_class]] }
|
|
|
|
if has_tooltip
|
|
name_tag_options[:title] = author.to_reference
|
|
name_tag_options[:data] = { placement: 'top' }
|
|
name_tag_options[:class] << 'has-tooltip'
|
|
end
|
|
|
|
# NOTE: ActionView::Helpers::TagHelper#content_tag HTML escapes username
|
|
content_tag(:span, username, name_tag_options)
|
|
end
|
|
|
|
def link_to_member(project, author, opts = {}, &block)
|
|
default_opts = { avatar: true, name: true, title: ":name" }
|
|
opts = default_opts.merge(opts)
|
|
|
|
return "(deleted)" unless author
|
|
|
|
data_attrs = {
|
|
user_id: author.id,
|
|
username: author.username,
|
|
name: author.name
|
|
}
|
|
|
|
inject_classes = ["author-link", opts[:extra_class]]
|
|
|
|
if opts[:name]
|
|
inject_classes.concat(["js-user-link", opts[:mobile_classes]])
|
|
else
|
|
inject_classes.append("has-tooltip")
|
|
end
|
|
|
|
inject_classes = inject_classes.compact.join(" ")
|
|
|
|
author_html = []
|
|
# Build avatar image tag
|
|
author_html << link_to_member_avatar(author, opts) if opts[:avatar]
|
|
# Build name span tag
|
|
author_html << author_content_tag(author, opts) if opts[:name]
|
|
author_html << capture(&block) if block
|
|
author_html = author_html.join.html_safe
|
|
|
|
if opts[:name]
|
|
link_to(author_html, user_path(author), class: inject_classes, data: data_attrs).html_safe
|
|
else
|
|
title = opts[:title].sub(":name", sanitize(author.name))
|
|
link_to(author_html, user_path(author), class: inject_classes, title: title, data: { container: 'body', qa_selector: 'assignee_link' }).html_safe
|
|
end
|
|
end
|
|
|
|
def project_title(project)
|
|
namespace_link = build_namespace_breadcrumb_link(project)
|
|
project_link = build_project_breadcrumb_link(project)
|
|
|
|
namespace_link = breadcrumb_list_item(namespace_link) unless project.group
|
|
project_link = breadcrumb_list_item project_link
|
|
|
|
"#{namespace_link} #{project_link}".html_safe
|
|
end
|
|
|
|
def remove_project_message(project)
|
|
_("You are going to delete %{project_full_name}. Deleted projects CANNOT be restored! Are you ABSOLUTELY sure?") %
|
|
{ project_full_name: project.full_name }
|
|
end
|
|
|
|
def transfer_project_message(project)
|
|
_("You are going to transfer %{project_full_name} to another namespace. Are you ABSOLUTELY sure?") %
|
|
{ project_full_name: project.full_name }
|
|
end
|
|
|
|
def remove_fork_project_description_message(project)
|
|
source = visible_fork_source(project)
|
|
|
|
if source
|
|
msg = _('This will remove the fork relationship between this project and %{fork_source}.') %
|
|
{ fork_source: link_to(source.full_name, project_path(source)) }
|
|
|
|
msg.html_safe
|
|
else
|
|
_('This will remove the fork relationship between this project and other projects in the fork network.')
|
|
end
|
|
end
|
|
|
|
def vue_fork_divergence_data(project, ref)
|
|
source_project = visible_fork_source(project)
|
|
|
|
return {} unless source_project
|
|
|
|
source_default_branch = source_project.default_branch
|
|
|
|
merge_request =
|
|
MergeRequest.opened
|
|
.from_project(project).of_projects(source_project.id).from_source_branches(ref).first
|
|
|
|
{
|
|
project_path: project.full_path,
|
|
selected_branch: ref,
|
|
source_name: source_project.full_name,
|
|
source_path: project_path(source_project),
|
|
source_default_branch: source_default_branch,
|
|
can_sync_branch: can_sync_branch?(project, ref).to_s,
|
|
ahead_compare_path: project_compare_path(
|
|
project, from: source_default_branch, to: ref, from_project_id: source_project.id
|
|
),
|
|
create_mr_path: create_merge_request_path(project, source_project, ref, merge_request),
|
|
view_mr_path: merge_request && project_merge_request_path(source_project, merge_request),
|
|
behind_compare_path: project_compare_path(
|
|
source_project, from: ref, to: source_default_branch, from_project_id: project.id
|
|
)
|
|
}
|
|
end
|
|
|
|
def remove_fork_project_warning_message(project)
|
|
_("You are going to remove the fork relationship from %{project_full_name}. Are you ABSOLUTELY sure?") %
|
|
{ project_full_name: project.full_name }
|
|
end
|
|
|
|
def remove_fork_project_confirm_json(project, remove_form_id)
|
|
{
|
|
remove_form_id: remove_form_id,
|
|
button_text: _('Remove fork relationship'),
|
|
confirm_danger_message: remove_fork_project_warning_message(project),
|
|
phrase: @project.path
|
|
}
|
|
end
|
|
|
|
def visible_fork_source(project)
|
|
project.fork_source if project.fork_source && can?(current_user, :read_project, project.fork_source)
|
|
end
|
|
|
|
def project_search_tabs?(tab)
|
|
return false unless @project.present?
|
|
|
|
abilities = Array(search_tab_ability_map[tab])
|
|
|
|
abilities.any? { |ability| can?(current_user, ability, @project) }
|
|
end
|
|
|
|
def can_change_visibility_level?(project, current_user)
|
|
can?(current_user, :change_visibility_level, project)
|
|
end
|
|
|
|
def can_disable_emails?(project, current_user)
|
|
return false if project.group&.emails_disabled?
|
|
|
|
can?(current_user, :set_emails_disabled, project)
|
|
end
|
|
|
|
def last_push_event
|
|
current_user&.recent_push(@project)
|
|
end
|
|
|
|
def link_to_autodeploy_doc
|
|
link_to _('About auto deploy'), help_page_path('topics/autodevops/stages.md', anchor: 'auto-deploy'), target: '_blank', rel: 'noopener'
|
|
end
|
|
|
|
def autodeploy_flash_notice(branch_name)
|
|
html_escape(_("Branch %{branch_name} was created. To set up auto deploy, choose a GitLab CI Yaml template and commit your changes. %{link_to_autodeploy_doc}")) %
|
|
{ branch_name: tag.strong(truncate(sanitize(branch_name))), link_to_autodeploy_doc: link_to_autodeploy_doc }
|
|
end
|
|
|
|
def project_list_cache_key(project, pipeline_status: true)
|
|
key = [
|
|
project.star_count,
|
|
project.route.cache_key,
|
|
project.cache_key,
|
|
project.last_activity_date,
|
|
controller.controller_name,
|
|
controller.action_name,
|
|
Gitlab::CurrentSettings.cache_key,
|
|
"cross-project:#{can?(current_user, :read_cross_project)}",
|
|
max_project_member_access_cache_key(project),
|
|
pipeline_status,
|
|
Gitlab::I18n.locale,
|
|
'v2.6'
|
|
]
|
|
|
|
key << pipeline_status_cache_key(project.pipeline_status) if pipeline_status && project.pipeline_status.has_status?
|
|
|
|
key
|
|
end
|
|
|
|
def load_pipeline_status(projects)
|
|
Gitlab::Cache::Ci::ProjectPipelineStatus
|
|
.load_in_batch_for_projects(projects)
|
|
end
|
|
|
|
def last_pipeline_from_status_cache(project)
|
|
if Feature.enabled?(:last_pipeline_from_pipeline_status, project)
|
|
pipeline_status = project.pipeline_status
|
|
return unless pipeline_status.has_status?
|
|
|
|
# commits have far more attributes than id, but last_pipeline only requires sha
|
|
return Commit.from_hash({ id: pipeline_status.sha }, project).last_pipeline
|
|
end
|
|
|
|
project.last_pipeline
|
|
end
|
|
|
|
def show_no_ssh_key_message?
|
|
Gitlab::CurrentSettings.user_show_add_ssh_key_message? &&
|
|
cookies[:hide_no_ssh_message].blank? &&
|
|
!current_user.hide_no_ssh_key &&
|
|
current_user.require_ssh_key?
|
|
end
|
|
|
|
def show_no_password_message?
|
|
cookies[:hide_no_password_message].blank? && !current_user.hide_no_password &&
|
|
current_user.require_extra_setup_for_git_auth?
|
|
end
|
|
|
|
def show_auto_devops_implicitly_enabled_banner?(project, user)
|
|
return false unless user_can_see_auto_devops_implicitly_enabled_banner?(project, user)
|
|
|
|
cookies["hide_auto_devops_implicitly_enabled_banner_#{project.id}".to_sym].blank?
|
|
end
|
|
|
|
def show_mobile_devops_project_promo?(project)
|
|
return false unless ::Feature.enabled?(:mobile_devops_projects_promo, project)
|
|
|
|
return false unless (project.project_setting.target_platforms & ::ProjectSetting::ALLOWED_TARGET_PLATFORMS).any?
|
|
|
|
cookies["hide_mobile_devops_promo_#{project.id}".to_sym].blank?
|
|
end
|
|
|
|
def no_password_message
|
|
push_pull_link_start = '<a href="%{url}" target="_blank" rel="noopener noreferrer">'.html_safe % { url: help_page_path('topics/git/terminology', anchor: 'pull-and-push') }
|
|
clone_with_https_link_start = '<a href="%{url}" target="_blank" rel="noopener noreferrer">'.html_safe % { url: help_page_path('gitlab-basics/start-using-git', anchor: 'clone-with-https') }
|
|
set_password_link_start = '<a href="%{url}">'.html_safe % { url: edit_profile_password_path }
|
|
set_up_pat_link_start = '<a href="%{url}">'.html_safe % { url: profile_personal_access_tokens_path }
|
|
|
|
message = if current_user.require_password_creation_for_git?
|
|
_('Your account is authenticated with SSO or SAML. To %{push_pull_link_start}push and pull%{link_end} over %{protocol} with Git using this account, you must %{set_password_link_start}set a password%{link_end} or %{set_up_pat_link_start}set up a Personal Access Token%{link_end} to use instead of a password. For more information, see %{clone_with_https_link_start}Clone with HTTPS%{link_end}.')
|
|
else
|
|
_('Your account is authenticated with SSO or SAML. To %{push_pull_link_start}push and pull%{link_end} over %{protocol} with Git using this account, you must %{set_up_pat_link_start}set up a Personal Access Token%{link_end} to use instead of a password. For more information, see %{clone_with_https_link_start}Clone with HTTPS%{link_end}.')
|
|
end
|
|
|
|
html_escape(message) % {
|
|
push_pull_link_start: push_pull_link_start,
|
|
protocol: gitlab_config.protocol.upcase,
|
|
clone_with_https_link_start: clone_with_https_link_start,
|
|
set_password_link_start: set_password_link_start,
|
|
set_up_pat_link_start: set_up_pat_link_start,
|
|
link_end: '</a>'.html_safe
|
|
}
|
|
end
|
|
|
|
# Returns true if any projects are present.
|
|
#
|
|
# If the relation has a LIMIT applied we'll cast the relation to an Array
|
|
# since repeated any? checks would otherwise result in multiple COUNT queries
|
|
# being executed.
|
|
#
|
|
# If no limit is applied we'll just issue a COUNT since the result set could
|
|
# be too large to load into memory.
|
|
def any_projects?(projects)
|
|
return projects.any? if projects.is_a?(Array)
|
|
|
|
if projects.limit_value
|
|
projects.to_a.any?
|
|
else
|
|
projects.except(:offset).any?
|
|
end
|
|
end
|
|
|
|
def show_projects?(projects, params)
|
|
!!(params[:personal] || params[:name] || params[:language] || any_projects?(projects))
|
|
end
|
|
|
|
def push_to_create_project_command(user = current_user)
|
|
repository_url =
|
|
if Gitlab::CurrentSettings.current_application_settings.enabled_git_access_protocol == 'http'
|
|
user_url(user)
|
|
else
|
|
Gitlab.config.gitlab_shell.ssh_path_prefix + user.username
|
|
end
|
|
|
|
"git push --set-upstream #{repository_url}/$(git rev-parse --show-toplevel | xargs basename).git $(git rev-parse --abbrev-ref HEAD)"
|
|
end
|
|
|
|
def show_xcode_link?(project = @project)
|
|
browser.platform.mac? && project.repository.xcode_project?
|
|
end
|
|
|
|
def xcode_uri_to_repo(project = @project)
|
|
"xcode://clone?repo=#{CGI.escape(default_url_to_repo(project))}"
|
|
end
|
|
|
|
def explore_projects_tab?
|
|
current_page?(explore_projects_path) ||
|
|
current_page?(trending_explore_projects_path) ||
|
|
current_page?(starred_explore_projects_path)
|
|
end
|
|
|
|
def show_count?(disabled: false, compact_mode: false)
|
|
!disabled && !compact_mode
|
|
end
|
|
|
|
def error_tracking_setting_project_json
|
|
setting = @project.error_tracking_setting
|
|
|
|
return if setting.blank? || setting.project_slug.blank? ||
|
|
setting.organization_slug.blank?
|
|
|
|
{
|
|
sentry_project_id: setting.sentry_project_id,
|
|
name: setting.project_name,
|
|
organization_name: setting.organization_name,
|
|
organization_slug: setting.organization_slug,
|
|
slug: setting.project_slug
|
|
}.to_json
|
|
end
|
|
|
|
def directory?
|
|
@path.present?
|
|
end
|
|
|
|
def external_classification_label_help_message
|
|
default_label = ::Gitlab::CurrentSettings.current_application_settings
|
|
.external_authorization_service_default_label
|
|
|
|
s_(
|
|
"ExternalAuthorizationService|When no classification label is set the "\
|
|
"default label `%{default_label}` will be used."
|
|
) % { default_label: default_label }
|
|
end
|
|
|
|
def can_admin_project_member?(project)
|
|
Ability.allowed?(current_user, :admin_project_member, project) && !membership_locked?
|
|
end
|
|
|
|
def project_can_be_shared?
|
|
!membership_locked? || @project.allowed_to_share_with_group?
|
|
end
|
|
|
|
def membership_locked?
|
|
false
|
|
end
|
|
|
|
def metrics_external_dashboard_url
|
|
@project.metrics_setting_external_dashboard_url
|
|
end
|
|
|
|
def metrics_dashboard_timezone
|
|
@project.metrics_setting_dashboard_timezone
|
|
end
|
|
|
|
def grafana_integration_url
|
|
@project.grafana_integration&.grafana_url
|
|
end
|
|
|
|
def grafana_integration_masked_token
|
|
@project.grafana_integration&.masked_token
|
|
end
|
|
|
|
def grafana_integration_enabled?
|
|
@project.grafana_integration&.enabled?
|
|
end
|
|
|
|
def project_license_name(project)
|
|
key = "project:#{project.id}:license_name"
|
|
|
|
Gitlab::SafeRequestStore.fetch(key) { project.repository.license&.name }
|
|
rescue GRPC::Unavailable, GRPC::DeadlineExceeded, Gitlab::Git::CommandError => e
|
|
Gitlab::ErrorTracking.track_exception(e)
|
|
Gitlab::SafeRequestStore[key] = nil
|
|
|
|
nil
|
|
end
|
|
|
|
def show_terraform_banner?(project)
|
|
Feature.enabled?(:show_terraform_banner, type: :ops) && project.repository_languages.with_programming_language('HCL').exists? && project.terraform_states.empty?
|
|
end
|
|
|
|
def project_permissions_panel_data(project)
|
|
{
|
|
packagesAvailable: ::Gitlab.config.packages.enabled,
|
|
packagesHelpPath: help_page_path('user/packages/index'),
|
|
currentSettings: project_permissions_settings(project),
|
|
canDisableEmails: can_disable_emails?(project, current_user),
|
|
canChangeVisibilityLevel: can_change_visibility_level?(project, current_user),
|
|
allowedVisibilityOptions: project_allowed_visibility_levels(project),
|
|
visibilityHelpPath: help_page_path('user/public_access'),
|
|
registryAvailable: Gitlab.config.registry.enabled,
|
|
registryHelpPath: help_page_path('user/packages/container_registry/index'),
|
|
lfsAvailable: Gitlab.config.lfs.enabled,
|
|
lfsHelpPath: help_page_path('topics/git/lfs/index'),
|
|
lfsObjectsExist: project.lfs_objects.exists?,
|
|
lfsObjectsRemovalHelpPath: help_page_path('topics/git/lfs/index', anchor: 'removing-objects-from-lfs'),
|
|
pagesAvailable: Gitlab.config.pages.enabled,
|
|
pagesAccessControlEnabled: Gitlab.config.pages.access_control,
|
|
pagesAccessControlForced: ::Gitlab::Pages.access_control_is_forced?,
|
|
pagesHelpPath: help_page_path('user/project/pages/introduction', anchor: 'gitlab-pages-access-control'),
|
|
issuesHelpPath: help_page_path('user/project/issues/index'),
|
|
membersPagePath: project_project_members_path(project),
|
|
environmentsHelpPath: help_page_path('ci/environments/index'),
|
|
featureFlagsHelpPath: help_page_path('operations/feature_flags'),
|
|
releasesHelpPath: help_page_path('user/project/releases/index'),
|
|
infrastructureHelpPath: help_page_path('user/infrastructure/index')
|
|
}
|
|
end
|
|
|
|
def project_classes(project)
|
|
return "project-highlight-puc" if project.warn_about_potentially_unwanted_characters?
|
|
|
|
""
|
|
end
|
|
|
|
# Returns the confirm phrase the user needs to type in order to delete the project
|
|
#
|
|
# Thus the phrase should include the namespace to make it very clear to the
|
|
# user which project is subject to deletion.
|
|
# Relevant issue: https://gitlab.com/gitlab-org/gitlab/-/issues/343591
|
|
def delete_confirm_phrase(project)
|
|
project.path_with_namespace
|
|
end
|
|
|
|
def able_to_see_issues?(project, user)
|
|
project.issues_enabled? && can?(user, :read_issue, project)
|
|
end
|
|
|
|
def able_to_see_merge_requests?(project, user)
|
|
project.merge_requests_enabled? && can?(user, :read_merge_request, project)
|
|
end
|
|
|
|
def able_to_see_forks_count?(project, user)
|
|
project.forking_enabled? && can?(user, :read_code, project)
|
|
end
|
|
|
|
def fork_button_disabled_tooltip(project)
|
|
return unless current_user
|
|
|
|
if !current_user.can?(:fork_project, project)
|
|
s_("ProjectOverview|You don't have permission to fork this project")
|
|
elsif !current_user.can?(:create_fork)
|
|
s_('ProjectOverview|You have reached your project limit')
|
|
end
|
|
end
|
|
|
|
def import_from_bitbucket_message
|
|
configure_oauth_import_message('Bitbucket', help_page_path("integration/bitbucket"))
|
|
end
|
|
|
|
def import_from_gitlab_message
|
|
configure_oauth_import_message('GitLab.com', help_page_path("integration/gitlab"))
|
|
end
|
|
|
|
def show_inactive_project_deletion_banner?(project)
|
|
return false unless project.present? && project.saved?
|
|
return false unless delete_inactive_projects?
|
|
|
|
project.inactive?
|
|
end
|
|
|
|
def inactive_project_deletion_date(project)
|
|
Gitlab::InactiveProjectsDeletionWarningTracker.new(project.id).scheduled_deletion_date
|
|
end
|
|
|
|
def show_clusters_alert?(project)
|
|
Gitlab.com? && can_admin_associated_clusters?(project)
|
|
end
|
|
|
|
def clusters_deprecation_alert_message
|
|
if has_active_license?
|
|
s_('ClusterIntegration|The certificate-based Kubernetes integration has been deprecated and will be turned off at the end of February 2023. Please %{linkStart}migrate to the GitLab agent for Kubernetes%{linkEnd}. Contact GitLab Support if you have any additional questions.')
|
|
else
|
|
s_('ClusterIntegration|The certificate-based Kubernetes integration has been deprecated and will be turned off at the end of February 2023. Please %{linkStart}migrate to the GitLab agent for Kubernetes%{linkEnd}.')
|
|
end
|
|
end
|
|
|
|
def project_coverage_chart_data_attributes(daily_coverage_options, ref)
|
|
{
|
|
graph_endpoint: "#{daily_coverage_options[:graph_api_path]}?#{daily_coverage_options[:base_params].to_query}",
|
|
graph_start_date: daily_coverage_options[:base_params][:start_date].strftime('%b %d'),
|
|
graph_end_date: daily_coverage_options[:base_params][:end_date].strftime('%b %d'),
|
|
graph_ref: ref.to_s,
|
|
graph_csv_path: "#{daily_coverage_options[:download_path]}?#{daily_coverage_options[:base_params].to_query}"
|
|
}
|
|
end
|
|
|
|
def localized_project_human_access(access)
|
|
localized_access_names[access] || Gitlab::Access.human_access(access)
|
|
end
|
|
|
|
def badge_count(number)
|
|
format_cached_count(1000, number)
|
|
end
|
|
|
|
def remote_mirror_setting_enabled?
|
|
false
|
|
end
|
|
|
|
def http_clone_url_to_repo(project)
|
|
project.http_url_to_repo
|
|
end
|
|
|
|
def ssh_clone_url_to_repo(project)
|
|
project.ssh_url_to_repo
|
|
end
|
|
|
|
private
|
|
|
|
def create_merge_request_path(project, source_project, ref, merge_request)
|
|
return if merge_request.present?
|
|
return unless can?(current_user, :create_merge_request_from, project)
|
|
return unless can?(current_user, :create_merge_request_in, source_project)
|
|
|
|
create_mr_path(
|
|
from: ref,
|
|
source_project: project,
|
|
to: source_project.default_branch,
|
|
target_project: source_project)
|
|
end
|
|
|
|
def can_sync_branch?(project, ref)
|
|
return false unless project.repository.branch_exists?(ref)
|
|
|
|
::Gitlab::UserAccess.new(current_user, container: project).can_push_to_branch?(ref)
|
|
end
|
|
|
|
def localized_access_names
|
|
{
|
|
Gitlab::Access::NO_ACCESS => _('No access'),
|
|
Gitlab::Access::MINIMAL_ACCESS => _("Minimal Access"),
|
|
Gitlab::Access::GUEST => _('Guest'),
|
|
Gitlab::Access::REPORTER => _('Reporter'),
|
|
Gitlab::Access::DEVELOPER => _('Developer'),
|
|
Gitlab::Access::MAINTAINER => _('Maintainer'),
|
|
Gitlab::Access::OWNER => _('Owner')
|
|
}
|
|
end
|
|
|
|
def configure_oauth_import_message(provider, help_url)
|
|
str = if current_user.can_admin_all_resources?
|
|
'ImportProjects|To enable importing projects from %{provider}, as administrator you need to configure %{link_start}OAuth integration%{link_end}'
|
|
else
|
|
'ImportProjects|To enable importing projects from %{provider}, ask your GitLab administrator to configure %{link_start}OAuth integration%{link_end}'
|
|
end
|
|
|
|
link_start = '<a href="%{url}" target="_blank" rel="noopener noreferrer">'.html_safe % { url: help_url }
|
|
s_(str).html_safe % { provider: provider, link_start: link_start, link_end: '</a>'.html_safe }
|
|
end
|
|
|
|
def tab_ability_map
|
|
{
|
|
cycle_analytics: :read_cycle_analytics,
|
|
environments: :read_environment,
|
|
metrics_dashboards: :metrics_dashboard,
|
|
milestones: :read_milestone,
|
|
snippets: :read_snippet,
|
|
settings: :admin_project,
|
|
builds: :read_build,
|
|
clusters: :read_cluster,
|
|
serverless: :read_cluster,
|
|
terraform: :read_terraform_state,
|
|
error_tracking: :read_sentry_issue,
|
|
alert_management: :read_alert_management_alert,
|
|
incidents: :read_issue,
|
|
labels: :read_label,
|
|
issues: :read_issue,
|
|
project_members: :read_project_member,
|
|
wiki: :read_wiki,
|
|
feature_flags: :read_feature_flag,
|
|
analytics: :read_analytics
|
|
}
|
|
end
|
|
|
|
def search_tab_ability_map
|
|
@search_tab_ability_map ||= tab_ability_map.merge(
|
|
blobs: :read_code,
|
|
commits: :read_code,
|
|
merge_requests: :read_merge_request,
|
|
notes: [:read_merge_request, :read_code, :read_issue, :read_snippet],
|
|
members: :read_project_member
|
|
)
|
|
end
|
|
|
|
def project_lfs_status(project)
|
|
if project.lfs_enabled?
|
|
content_tag(:span, class: 'lfs-enabled') do
|
|
s_('LFSStatus|Enabled')
|
|
end
|
|
else
|
|
content_tag(:span, class: 'lfs-disabled') do
|
|
s_('LFSStatus|Disabled')
|
|
end
|
|
end
|
|
end
|
|
|
|
def git_user_name
|
|
if current_user
|
|
current_user.name.gsub('"', '\"')
|
|
else
|
|
_("Your name")
|
|
end
|
|
end
|
|
|
|
def git_user_email
|
|
if current_user
|
|
current_user.commit_email_or_default
|
|
else
|
|
"your@email.com"
|
|
end
|
|
end
|
|
|
|
def default_url_to_repo(project = @project)
|
|
case default_clone_protocol
|
|
when 'ssh'
|
|
project.ssh_url_to_repo
|
|
else
|
|
project.http_url_to_repo
|
|
end
|
|
end
|
|
|
|
def default_clone_label
|
|
_("Copy %{protocol} clone URL") % { protocol: default_clone_protocol.upcase }
|
|
end
|
|
|
|
def default_clone_protocol
|
|
if allowed_protocols_present?
|
|
enabled_protocol
|
|
else
|
|
extra_default_clone_protocol
|
|
end
|
|
end
|
|
|
|
def extra_default_clone_protocol
|
|
if !current_user || current_user.require_ssh_key?
|
|
gitlab_config.protocol
|
|
else
|
|
'ssh'
|
|
end
|
|
end
|
|
|
|
def project_last_activity(project)
|
|
if project.last_activity_at
|
|
time_ago_with_tooltip(project.last_activity_at, placement: 'bottom', html_class: 'last_activity_time_ago')
|
|
else
|
|
s_("ProjectLastActivity|Never")
|
|
end
|
|
end
|
|
|
|
def project_status_css_class(status)
|
|
case status
|
|
when "started"
|
|
"table-active"
|
|
when "failed"
|
|
"table-danger"
|
|
when "finished"
|
|
"table-success"
|
|
end
|
|
end
|
|
|
|
def readme_cache_key
|
|
sha = @project.commit.try(:sha) || 'nil'
|
|
[@project.full_path, sha, "readme"].join('-')
|
|
end
|
|
|
|
def current_ref
|
|
@ref || @repository.try(:root_ref)
|
|
end
|
|
|
|
def project_child_container_class(view_path)
|
|
view_path == "projects/issues/issues" ? "gl-mt-3" : "project-show-#{view_path}"
|
|
end
|
|
|
|
def project_issues(project)
|
|
IssuesFinder.new(current_user, project_id: project.id).execute
|
|
end
|
|
|
|
def restricted_levels
|
|
return [] if current_user.can_admin_all_resources?
|
|
|
|
Gitlab::CurrentSettings.restricted_visibility_levels || []
|
|
end
|
|
|
|
def project_permissions_settings(project)
|
|
feature = project.project_feature
|
|
{
|
|
packagesEnabled: !!project.packages_enabled,
|
|
packageRegistryAccessLevel: feature.package_registry_access_level,
|
|
visibilityLevel: project.visibility_level,
|
|
requestAccessEnabled: !!project.request_access_enabled,
|
|
issuesAccessLevel: feature.issues_access_level,
|
|
repositoryAccessLevel: feature.repository_access_level,
|
|
forkingAccessLevel: feature.forking_access_level,
|
|
mergeRequestsAccessLevel: feature.merge_requests_access_level,
|
|
buildsAccessLevel: feature.builds_access_level,
|
|
wikiAccessLevel: feature.wiki_access_level,
|
|
snippetsAccessLevel: feature.snippets_access_level,
|
|
pagesAccessLevel: feature.pages_access_level,
|
|
analyticsAccessLevel: feature.analytics_access_level,
|
|
containerRegistryEnabled: !!project.container_registry_enabled,
|
|
lfsEnabled: !!project.lfs_enabled,
|
|
emailsDisabled: project.emails_disabled?,
|
|
metricsDashboardAccessLevel: feature.metrics_dashboard_access_level,
|
|
monitorAccessLevel: feature.monitor_access_level,
|
|
showDefaultAwardEmojis: project.show_default_award_emojis?,
|
|
warnAboutPotentiallyUnwantedCharacters: project.warn_about_potentially_unwanted_characters?,
|
|
enforceAuthChecksOnUploads: project.enforce_auth_checks_on_uploads?,
|
|
securityAndComplianceAccessLevel: project.security_and_compliance_access_level,
|
|
containerRegistryAccessLevel: feature.container_registry_access_level,
|
|
environmentsAccessLevel: feature.environments_access_level,
|
|
featureFlagsAccessLevel: feature.feature_flags_access_level,
|
|
releasesAccessLevel: feature.releases_access_level,
|
|
infrastructureAccessLevel: feature.infrastructure_access_level
|
|
}
|
|
end
|
|
|
|
def project_allowed_visibility_levels(project)
|
|
Gitlab::VisibilityLevel.values.select do |level|
|
|
project.visibility_level_allowed?(level) && !restricted_levels.include?(level)
|
|
end
|
|
end
|
|
|
|
def find_file_path
|
|
return unless @project && !@project.empty_repo?
|
|
return unless can?(current_user, :read_code, @project)
|
|
|
|
ref = @ref || @project.repository.root_ref
|
|
|
|
project_find_file_path(@project, ref)
|
|
end
|
|
|
|
def can_show_last_commit_in_list?(project)
|
|
can?(current_user, :read_cross_project) &&
|
|
can?(current_user, :read_commit_status, project) &&
|
|
project.commit
|
|
end
|
|
|
|
def pages_https_only_disabled?
|
|
!@project.pages_domains.all?(&:https?)
|
|
end
|
|
|
|
def pages_https_only_title
|
|
return unless pages_https_only_disabled?
|
|
|
|
"You must enable HTTPS for all your domains first"
|
|
end
|
|
|
|
def filter_starrer_path(options = {})
|
|
options = params.slice(:sort).merge(options).permit!
|
|
"#{request.path}?#{options.to_param}"
|
|
end
|
|
|
|
def sidebar_operations_paths
|
|
%w[
|
|
environments
|
|
clusters
|
|
cluster_agents
|
|
functions
|
|
error_tracking
|
|
alert_management
|
|
incidents
|
|
incident_management
|
|
user
|
|
gcp
|
|
logs
|
|
product_analytics
|
|
metrics_dashboard
|
|
feature_flags
|
|
terraform
|
|
]
|
|
end
|
|
|
|
def user_can_see_auto_devops_implicitly_enabled_banner?(project, user)
|
|
Ability.allowed?(user, :admin_project, project) &&
|
|
project.has_auto_devops_implicitly_enabled? &&
|
|
project.builds_enabled? &&
|
|
!project.repository.gitlab_ci_yml
|
|
end
|
|
|
|
def show_visibility_confirm_modal?(project)
|
|
project.visibility_level > Gitlab::VisibilityLevel::PRIVATE && project.forks_count > 0
|
|
end
|
|
|
|
def confirm_reduce_visibility_message(project)
|
|
strong_start = "<strong>".html_safe
|
|
strong_end = "</strong>".html_safe
|
|
message = _("You're about to reduce the visibility of the project %{strong_start}%{project_name}%{strong_end}.")
|
|
|
|
if project.group
|
|
message = _("You're about to reduce the visibility of the project %{strong_start}%{project_name}%{strong_end} in %{strong_start}%{group_name}%{strong_end}.")
|
|
end
|
|
|
|
html_escape(message) % { strong_start: strong_start, strong_end: strong_end, project_name: project.name, group_name: project.group ? project.group.name : nil }
|
|
end
|
|
|
|
def visibility_confirm_modal_data(project, target_form_id = nil)
|
|
{
|
|
target_form_id: target_form_id,
|
|
button_testid: 'reduce-project-visibility-button',
|
|
confirm_button_text: _('Reduce project visibility'),
|
|
confirm_danger_message: confirm_reduce_visibility_message(project),
|
|
phrase: project.full_path,
|
|
additional_information: _('Note: current forks will keep their visibility level.'),
|
|
html_confirmation_message: true.to_s,
|
|
show_visibility_confirm_modal: show_visibility_confirm_modal?(project).to_s
|
|
}
|
|
end
|
|
|
|
def build_project_breadcrumb_link(project)
|
|
project_name = simple_sanitize(project.name)
|
|
|
|
push_to_schema_breadcrumb(project_name, project_path(project))
|
|
|
|
link_to project_path(project) do
|
|
icon = project_icon(project, alt: project_name, class: 'avatar-tile', width: 15, height: 15) if project.avatar_url && !Rails.env.test?
|
|
[icon, content_tag("span", project_name, class: "breadcrumb-item-text js-breadcrumb-item-text")].join.html_safe
|
|
end
|
|
end
|
|
|
|
def build_namespace_breadcrumb_link(project)
|
|
if project.group
|
|
group_title(project.group, nil, nil)
|
|
else
|
|
owner = project.namespace.owner
|
|
name = simple_sanitize(owner.name)
|
|
url = user_path(owner)
|
|
|
|
push_to_schema_breadcrumb(name, url)
|
|
link_to(name, url)
|
|
end
|
|
end
|
|
|
|
def delete_inactive_projects?
|
|
strong_memoize(:delete_inactive_projects_setting) do
|
|
::Gitlab::CurrentSettings.delete_inactive_projects?
|
|
end
|
|
end
|
|
end
|
|
|
|
def can_admin_associated_clusters?(project)
|
|
can_admin_project_clusters?(project) || can_admin_group_clusters?(project)
|
|
end
|
|
|
|
def can_admin_project_clusters?(project)
|
|
project.clusters.any? && can?(current_user, :admin_cluster, project)
|
|
end
|
|
|
|
def can_admin_group_clusters?(project)
|
|
project.group && project.group.clusters.any? && can?(current_user, :admin_cluster, project.group)
|
|
end
|
|
|
|
def can_view_branch_rules?
|
|
can?(current_user, :maintainer_access, @project)
|
|
end
|
|
|
|
def branch_rules_path
|
|
project_settings_repository_path(@project, anchor: 'js-branch-rules')
|
|
end
|
|
|
|
ProjectsHelper.prepend_mod_with('ProjectsHelper')
|