BigW Consortium Gitlab

projects_helper.rb 12.7 KB
Newer Older
randx committed
1
module ProjectsHelper
2
  def link_to_project(project)
Josh Frye committed
3
    link_to [project.namespace.becomes(Namespace), project], title: h(project.name) do
4
      title = content_tag(:span, project.name, class: 'project-name')
5 6

      if project.namespace
7
        namespace = content_tag(:span, "#{project.namespace.human_name} / ", class: 'namespace-name')
8 9 10 11 12
        title = namespace + title
      end

      title
    end
13
  end
14

15 16 17
  def link_to_member_avatar(author, opts = {})
    default_opts = { avatar: true, name: true, size: 16, author_class: 'author', title: ":name" }
    opts = default_opts.merge(opts)
18
    image_tag(avatar_icon(author, opts[:size]), width: opts[:size], class: "avatar avatar-inline #{"s#{opts[:size]}" if opts[:size]}", alt: '') if opts[:avatar]
19 20
  end

Phil Hughes committed
21
  def link_to_member(project, author, opts = {}, &block)
22
    default_opts = { avatar: true, name: true, size: 16, author_class: 'author', title: ":name", tooltip: false }
23 24
    opts = default_opts.merge(opts)

25 26
    return "(deleted)" unless author

27 28
    author_html =  ""

29
    # Build avatar image tag
30
    author_html << image_tag(avatar_icon(author, opts[:size]), width: opts[:size], class: "avatar avatar-inline #{"s#{opts[:size]}" if opts[:size]} #{opts[:avatar_class] if opts[:avatar_class]}", alt: '') if opts[:avatar]
31

32
    # Build name span tag
33 34 35
    if opts[:by_username]
      author_html << content_tag(:span, sanitize("@#{author.username}"), class: opts[:author_class]) if opts[:name]
    else
36
      tooltip_data = { placement: 'top' }
Phil Hughes committed
37
      author_html << content_tag(:span, sanitize(author.name), class: [opts[:author_class], ('has-tooltip' if opts[:tooltip])], title: (author.to_reference if opts[:tooltip]), data: (tooltip_data if opts[:tooltip])) if opts[:name]
38
    end
39

Phil Hughes committed
40 41
    author_html << capture(&block) if block

42
    author_html = author_html.html_safe
43

44
    if opts[:name]
45
      link_to(author_html, user_path(author), class: "author_link #{"#{opts[:extra_class]}" if opts[:extra_class]} #{"#{opts[:mobile_classes]}" if opts[:mobile_classes]}").html_safe
46
    else
47
      title = opts[:title].sub(":name", sanitize(author.name))
48
      link_to(author_html, user_path(author), class: "author_link has-tooltip", title: title, data: { container: 'body' } ).html_safe
49
    end
50
  end
51

52
  def project_title(project)
53 54 55 56 57 58
    namespace_link =
      if project.group
        link_to(simple_sanitize(project.group.name), group_path(project.group))
      else
        owner = project.namespace.owner
        link_to(simple_sanitize(owner.name), user_path(owner))
59
      end
60

Phil Hughes committed
61
    project_link = link_to simple_sanitize(project.name), project_path(project), { class: "project-item-select-holder" }
62

Phil Hughes committed
63
    if current_user
64 65 66
      project_link << button_tag(type: 'button', class: "dropdown-toggle-caret js-projects-dropdown-toggle", aria: { label: "Toggle switch project dropdown" }, data: { target: ".js-dropdown-menu-projects", toggle: "dropdown" }) do
        icon("chevron-down")
      end
Phil Hughes committed
67 68
    end

69
    "#{namespace_link} / #{project_link}".html_safe
70
  end
71 72 73 74

  def remove_project_message(project)
    "You are going to remove #{project.name_with_namespace}.\n Removed project CANNOT be restored!\n Are you ABSOLUTELY sure?"
  end
75

76 77 78 79
  def transfer_project_message(project)
    "You are going to transfer #{project.name_with_namespace} to another owner. Are you ABSOLUTELY sure?"
  end

80
  def remove_fork_project_message(project)
Douwe Maan committed
81
    "You are going to remove the fork relationship to source project #{@project.forked_from_project.name_with_namespace}.  Are you ABSOLUTELY sure?"
82 83
  end

84 85 86 87 88 89 90 91
  def project_nav_tabs
    @nav_tabs ||= get_project_nav_tabs(@project, current_user)
  end

  def project_nav_tab?(name)
    project_nav_tabs.include? name
  end

Douwe Maan committed
92 93 94 95 96 97 98 99
  def project_for_deploy_key(deploy_key)
    if deploy_key.projects.include?(@project)
      @project
    else
      deploy_key.projects.find { |project| can?(current_user, :read_project, project) }
    end
  end

100 101 102 103 104 105 106 107 108 109
  def can_change_visibility_level?(project, current_user)
    return false unless can?(current_user, :change_visibility_level, project)

    if project.forked?
      project.forked_from_project.visibility_level > Gitlab::VisibilityLevel::PRIVATE
    else
      true
    end
  end

110
  def license_short_name(project)
111
    return 'LICENSE' if project.repository.license_key.nil?
112 113 114 115 116 117

    license = Licensee::License.new(project.repository.license_key)

    license.nickname || license.name
  end

118 119 120 121 122 123 124 125 126 127 128
  def last_push_event
    return unless current_user

    project_ids = [@project.id]
    if fork = current_user.fork_of(@project)
      project_ids << fork.id
    end

    current_user.recent_push(project_ids)
  end

129 130 131 132 133
  def project_feature_access_select(field)
    # Don't show option "everyone with access" if project is private
    options = project_feature_options

    if @project.private?
134
      level = @project.project_feature.send(field)
135
      options.delete('Everyone with access')
136
      highest_available_option = options.values.max if level == ProjectFeature::ENABLED
137 138 139
    end

    options = options_for_select(options, selected: highest_available_option || @project.project_feature.public_send(field))
140 141 142 143 144 145 146 147 148

    content_tag(
      :select,
      options,
      name: "project[project_feature_attributes][#{field}]",
      id: "project_project_feature_attributes_#{field}",
      class: "pull-right form-control #{repo_children_classes(field)}",
      data: { field: field }
    ).html_safe
149 150
  end

151 152
  private

153 154 155 156 157 158 159 160 161 162
  def repo_children_classes(field)
    needs_repo_check = [:merge_requests_access_level, :builds_access_level]
    return unless needs_repo_check.include?(field)

    classes = "project-repo-select js-repo-select"
    classes << " disabled" unless @project.feature_available?(:repository, current_user)

    classes
  end

163
  def get_project_nav_tabs(project, current_user)
164
    nav_tabs = [:home]
165

166
    if !project.empty_repo? && can?(current_user, :download_code, project)
167
      nav_tabs << [:files, :commits, :network, :graphs, :forks]
168 169
    end

170
    if project.repo_exists? && can?(current_user, :read_merge_request, project)
171 172 173
      nav_tabs << :merge_requests
    end

174
    if can?(current_user, :read_pipeline, project)
175
      nav_tabs << :pipelines
Kamil Trzcinski committed
176 177
    end

178 179 180 181
    if can?(current_user, :read_build, project)
      nav_tabs << :builds
    end

182
    if Gitlab.config.registry.enabled && can?(current_user, :read_container_image, project)
183
      nav_tabs << :container_registry
184 185
    end

186 187 188 189
    if can?(current_user, :read_environment, project)
      nav_tabs << :environments
    end

190 191 192 193
    if can?(current_user, :admin_project, project)
      nav_tabs << :settings
    end

194
    if can?(current_user, :read_project_member, project)
195 196 197
      nav_tabs << :team
    end

198 199
    if can?(current_user, :read_issue, project)
      nav_tabs << :issues
200 201
    end

202 203 204 205 206 207 208 209
    if can?(current_user, :read_wiki, project)
      nav_tabs << :wiki
    end

    if can?(current_user, :read_project_snippet, project)
      nav_tabs << :snippets
    end

210 211 212 213
    if can?(current_user, :read_label, project)
      nav_tabs << :labels
    end

214
    if can?(current_user, :read_milestone, project)
215
      nav_tabs << :milestones
216 217
    end

218 219
    nav_tabs.flatten
  end
220

221 222
  def project_lfs_status(project)
    if project.lfs_enabled?
223
      content_tag(:span, class: 'lfs-enabled') do
224 225 226
        'Enabled'
      end
    else
227
      content_tag(:span, class: 'lfs-disabled') do
228 229 230 231 232
        'Disabled'
      end
    end
  end

233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
  def git_user_name
    if current_user
      current_user.name
    else
      "Your name"
    end
  end

  def git_user_email
    if current_user
      current_user.email
    else
      "your@email.com"
    end
  end
248

249
  def repository_size(project = @project)
250 251
    size_in_bytes = project.repository_size * 1.megabyte
    number_to_human_size(size_in_bytes, delimiter: ',', precision: 2)
252
  end
253

254
  def default_url_to_repo(project = @project)
255 256
    case default_clone_protocol
    when 'ssh'
257 258 259 260
      project.ssh_url_to_repo
    else
      project.http_url_to_repo
    end
261
  end
262

263
  def default_clone_protocol
264 265
    if allowed_protocols_present?
      enabled_protocol
266
    else
267 268 269 270 271
      if !current_user || current_user.require_ssh_key?
        gitlab_config.protocol
      else
        'ssh'
      end
272
    end
273
  end
274 275 276

  def project_last_activity(project)
    if project.last_activity_at
277
      time_ago_with_tooltip(project.last_activity_at, placement: 'bottom', html_class: 'last_activity_time_ago')
278 279 280 281
    else
      "Never"
    end
  end
282

283 284 285 286 287 288 289 290
  def add_special_file_path(project, file_name:, commit_message: nil)
    namespace_project_new_blob_path(
      project.namespace,
      project,
      project.default_branch || 'master',
      file_name:      file_name,
      commit_message: commit_message || "Add #{file_name.downcase}"
    )
291 292
  end

293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
  def add_koding_stack_path(project)
    namespace_project_new_blob_path(
      project.namespace,
      project,
      project.default_branch || 'master',
      file_name:      '.koding.yml',
      commit_message: "Add Koding stack script",
      content: <<-CONTENT.strip_heredoc
        provider:
          aws:
            access_key: '${var.aws_access_key}'
            secret_key: '${var.aws_secret_key}'
        resource:
          aws_instance:
            #{project.path}-vm:
              instance_type: t2.nano
              user_data: |-

                # Created by GitLab UI for :>

                echo _KD_NOTIFY_@Installing Base packages...@

                apt-get update -y
                apt-get install git -y

                echo _KD_NOTIFY_@Cloning #{project.name}...@

                export KODING_USER=${var.koding_user_username}
                export REPO_URL=#{root_url}${var.koding_queryString_repo}.git
                export BRANCH=${var.koding_queryString_branch}

                sudo -i -u $KODING_USER git clone $REPO_URL -b $BRANCH

                echo _KD_NOTIFY_@#{project.name} cloned.@
      CONTENT
    )
  end

  def koding_project_url(project = nil, branch = nil, sha = nil)
    if project
      import_path = "/Home/Stacks/import"

      repo = project.path_with_namespace
      branch ||= project.default_branch
      sha ||= project.commit.short_id

      path = "#{import_path}?repo=#{repo}&branch=#{branch}&sha=#{sha}"

      return URI.join(current_application_settings.koding_url, path).to_s
    end

    current_application_settings.koding_url
  end

347
  def contribution_guide_path(project)
348
    if project && contribution_guide = project.repository.contribution_guide
Vinnie Okada committed
349 350 351 352
      namespace_project_blob_path(
        project.namespace,
        project,
        tree_join(project.default_branch,
353 354 355 356 357
                  contribution_guide.name)
      )
    end
  end

358 359 360 361
  def readme_path(project)
    filename_path(project, :readme)
  end

362
  def changelog_path(project)
363
    filename_path(project, :changelog)
364 365
  end

366
  def license_path(project)
367
    filename_path(project, :license_blob)
368 369
  end

370
  def version_path(project)
371
    filename_path(project, :version)
372
  end
373

374 375 376 377
  def ci_configuration_path(project)
    filename_path(project, :gitlab_ci_yml)
  end

378 379
  def project_wiki_path_with_version(proj, page, version, is_newest)
    url_params = is_newest ? {} : { version_id: version }
Vinnie Okada committed
380
    namespace_project_wiki_path(proj.namespace, proj, page, url_params)
381
  end
382

Valery Sizov committed
383 384 385 386 387 388 389 390 391 392
  def project_status_css_class(status)
    case status
    when "started"
      "active"
    when "failed"
      "danger"
    when "finished"
      "success"
    end
  end
393

394 395 396 397 398 399
  def new_readme_path
    ref = @repository.root_ref if @repository
    ref ||= 'master'

    namespace_project_new_blob_path(@project.namespace, @project, tree_join(ref), file_name: 'README.md')
  end
400

401 402 403 404 405 406 407
  def new_license_path
    ref = @repository.root_ref if @repository
    ref ||= 'master'

    namespace_project_new_blob_path(@project.namespace, @project, tree_join(ref), file_name: 'LICENSE')
  end

408
  def readme_cache_key
409
    sha = @project.commit.try(:sha) || 'nil'
410
    [@project.path_with_namespace, sha, "readme"].join('-')
411
  end
412 413 414 415 416 417 418 419 420 421 422 423 424 425

  def round_commit_count(project)
    count = project.commit_count

    if count > 10000
      '10000+'
    elsif count > 5000
      '5000+'
    elsif count > 1000
      '1000+'
    else
      count
    end
  end
426

427 428 429
  def current_ref
    @ref || @repository.try(:root_ref)
  end
430

431 432 433
  def filename_path(project, filename)
    if project && blob = project.repository.send(filename)
      namespace_project_blob_path(
434 435 436
        project.namespace,
        project,
        tree_join(project.default_branch, blob.name)
437 438 439
      )
    end
  end
440

441
  def sanitize_repo_path(project, message)
442 443
    return '' unless message.present?

444
    message.strip.gsub(project.repository_storage_path.chomp('/'), "[REPOS PATH]")
445
  end
446 447 448 449 450 451 452 453

  def project_feature_options
    {
      'Disabled' => ProjectFeature::DISABLED,
      'Only team members' => ProjectFeature::PRIVATE,
      'Everyone with access' => ProjectFeature::ENABLED
    }
  end
454 455 456 457

  def project_child_container_class(view_path)
    view_path == "projects/issues/issues" ? "prepend-top-default" : "project-show-#{view_path}"
  end
randx committed
458
end