BigW Consortium Gitlab

entities.rb 35.5 KB
Newer Older
1
module API
Nihad Abbasov committed
2
  module Entities
3 4 5 6 7 8 9 10 11 12
    class WikiPageBasic < Grape::Entity
      expose :format
      expose :slug
      expose :title
    end

    class WikiPage < WikiPageBasic
      expose :content
    end

13
    class UserSafe < Grape::Entity
14
      expose :id, :name, :username
15
    end
16

17
    class UserBasic < UserSafe
18
      expose :state
19

20 21 22
      expose :avatar_url do |user, options|
        user.avatar_url(only_path: false)
      end
Douwe Maan committed
23

24 25
      expose :avatar_path, if: ->(user, options) { options.fetch(:only_path, false) && user.avatar_path }

Douwe Maan committed
26
      expose :web_url do |user, options|
27
        Gitlab::Routing.url_helpers.user_url(user)
Douwe Maan committed
28
      end
Nihad Abbasov committed
29
    end
Nihad Abbasov committed
30

31 32
    class User < UserBasic
      expose :created_at
33
      expose :bio, :location, :skype, :linkedin, :twitter, :website_url, :organization
34 35
    end

36 37
    class UserActivity < Grape::Entity
      expose :username
38 39
      expose :last_activity_on
      expose :last_activity_on, as: :last_activity_at # Back-compat
40 41
    end

42 43 44 45
    class Identity < Grape::Entity
      expose :provider, :extern_uid
    end

46
    class UserPublic < User
47 48
      expose :last_sign_in_at
      expose :confirmed_at
49
      expose :last_activity_on
50
      expose :email
51
      expose :theme_id, :color_scheme_id, :projects_limit, :current_sign_in_at
52
      expose :identities, using: Entities::Identity
53 54
      expose :can_create_group?, as: :can_create_group
      expose :can_create_project?, as: :can_create_project
55
      expose :two_factor_enabled?, as: :two_factor_enabled
56
      expose :external
57 58
    end

59
    class UserWithAdmin < UserPublic
60
      expose :admin?, as: :is_admin
61 62
    end

63 64 65 66
    class Email < Grape::Entity
      expose :id, :email
    end

miks committed
67
    class Hook < Grape::Entity
68
      expose :id, :url, :created_at, :push_events, :tag_push_events, :repository_update_events
69
      expose :enable_ssl_verification
miks committed
70 71
    end

72
    class ProjectHook < Hook
73
      expose :project_id, :issues_events, :merge_requests_events
74
      expose :note_events, :pipeline_events, :wiki_page_events
75
      expose :job_events
76 77
    end

78 79 80 81 82 83 84 85
    class SharedGroup < Grape::Entity
      expose :group_id
      expose :group_name do |group_link, options|
        group_link.group.name
      end
      expose :group_access, as: :group_access_level
    end

86 87
    class ProjectIdentity < Grape::Entity
      expose :id, :description
88 89
      expose :name, :name_with_namespace
      expose :path, :path_with_namespace
90 91 92
      expose :created_at
    end

93
    class BasicProjectDetails < ProjectIdentity
Francisco Lopez committed
94 95 96 97 98 99 100 101 102 103 104
      include ::API::ProjectsRelationBuilder

      expose :default_branch
      # Avoids an N+1 query: https://github.com/mbleigh/acts-as-taggable-on/issues/91#issuecomment-168273770
      expose :tag_list do |project|
        # project.tags.order(:name).pluck(:name) is the most suitable option
        # to avoid loading all the ActiveRecord objects but, if we use it here
        # it override the preloaded associations and makes a query
        # (fixed in https://github.com/rails/rails/pull/25976).
        project.tags.map(&:name).sort
      end
105
      expose :ssh_url_to_repo, :http_url_to_repo, :web_url
106 107 108
      expose :avatar_url do |project, options|
        project.avatar_url(only_path: false)
      end
109
      expose :star_count, :forks_count
Francisco Lopez committed
110
      expose :last_activity_at
111

112
      def self.preload_relation(projects_relation, options =  {})
113 114 115 116
        projects_relation.preload(:project_feature, :route)
                         .preload(namespace: [:route, :owner],
                                  tags: :taggings)
      end
117 118
    end

119
    class Project < BasicProjectDetails
120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
      include ::API::Helpers::RelatedResourcesHelpers

      expose :_links do
        expose :self do |project|
          expose_url(api_v4_projects_path(id: project.id))
        end

        expose :issues, if: -> (*args) { issues_available?(*args) } do |project|
          expose_url(api_v4_projects_issues_path(id: project.id))
        end

        expose :merge_requests, if: -> (*args) { mrs_available?(*args) } do |project|
          expose_url(api_v4_projects_merge_requests_path(id: project.id))
        end

        expose :repo_branches do |project|
          expose_url(api_v4_projects_repository_branches_path(id: project.id))
        end

        expose :labels do |project|
          expose_url(api_v4_projects_labels_path(id: project.id))
        end

        expose :events do |project|
          expose_url(api_v4_projects_events_path(id: project.id))
        end

        expose :members do |project|
          expose_url(api_v4_projects_members_path(id: project.id))
        end
      end

152
      expose :archived?, as: :archived
153
      expose :visibility
154
      expose :owner, using: Entities::UserBasic, unless: ->(project, options) { project.group }
155
      expose :resolve_outdated_diff_discussions
156 157 158
      expose :container_registry_enabled

      # Expose old field names with the new permissions methods to keep API compatible
159 160 161
      expose(:issues_enabled) { |project, options| project.feature_available?(:issues, options[:current_user]) }
      expose(:merge_requests_enabled) { |project, options| project.feature_available?(:merge_requests, options[:current_user]) }
      expose(:wiki_enabled) { |project, options| project.feature_available?(:wiki, options[:current_user]) }
162
      expose(:jobs_enabled) { |project, options| project.feature_available?(:builds, options[:current_user]) }
163
      expose(:snippets_enabled) { |project, options| project.feature_available?(:snippets, options[:current_user]) }
164

165 166
      expose :shared_runners_enabled
      expose :lfs_enabled?, as: :lfs_enabled
167
      expose :creator_id
168
      expose :namespace, using: 'API::Entities::NamespaceBasic'
169
      expose :forked_from_project, using: Entities::BasicProjectDetails, if: lambda { |project, options| project.forked? }
170 171
      expose :import_status
      expose :import_error, if: lambda { |_project, options| options[:user_can_admin_project] }
172

173
      expose :open_issues_count, if: lambda { |project, options| project.feature_available?(:issues, options[:current_user]) }
174
      expose :runners_token, if: lambda { |_project, options| options[:user_can_admin_project] }
175
      expose :public_builds, as: :public_jobs
176
      expose :ci_config_path
177
      expose :shared_with_groups do |project, options|
178
        SharedGroup.represent(project.project_group_links, options)
179
      end
180
      expose :only_allow_merge_if_pipeline_succeeds
181
      expose :request_access_enabled
182
      expose :only_allow_merge_if_all_discussions_are_resolved
183
      expose :printing_merge_request_link_enabled
184 185

      expose :statistics, using: 'API::Entities::ProjectStatistics', if: :statistics
186 187

      def self.preload_relation(projects_relation, options =  {})
188 189 190 191 192
        super(projects_relation).preload(:group)
                                .preload(project_group_links: :group,
                                         fork_network: :root_project,
                                         forked_project_link: :forked_from_project,
                                         forked_from_project: [:route, :forks, namespace: :route, tags: :taggings])
193 194 195
      end

      def self.forks_counting_projects(projects_relation)
196
        projects_relation + projects_relation.map(&:forked_from_project).compact
197
      end
198 199 200 201 202 203 204
    end

    class ProjectStatistics < Grape::Entity
      expose :commit_count
      expose :storage_size
      expose :repository_size
      expose :lfs_objects_size
205
      expose :build_artifacts_size, as: :job_artifacts_size
Nihad Abbasov committed
206 207
    end

208
    class Member < UserBasic
209
      expose :access_level do |user, options|
210
        member = options[:member] || options[:source].members.find_by(user_id: user.id)
211 212
        member.access_level
      end
213
      expose :expires_at do |user, options|
214
        member = options[:member] || options[:source].members.find_by(user_id: user.id)
215 216
        member.expires_at
      end
217 218 219 220
    end

    class AccessRequester < UserBasic
      expose :requested_at do |user, options|
221
        access_requester = options[:access_requester] || options[:source].requesters.find_by(user_id: user.id)
222
        access_requester.requested_at
223
      end
224 225
    end

226
    class Group < Grape::Entity
227
      expose :id, :name, :path, :description, :visibility
228
      expose :lfs_enabled?, as: :lfs_enabled
229 230
      expose :avatar_url do |group, options|
        group.avatar_url(only_path: false)
231
      end
232
      expose :web_url
233
      expose :request_access_enabled
234
      expose :full_name, :full_path
235 236 237 238

      if ::Group.supports_nested_groups?
        expose :parent_id
      end
239 240 241 242 243 244

      expose :statistics, if: :statistics do
        with_options format_with: -> (value) { value.to_i } do
          expose :storage_size
          expose :repository_size
          expose :lfs_objects_size
245
          expose :build_artifacts_size, as: :job_artifacts_size
246 247
        end
      end
248
    end
Andrew8xx8 committed
249

250
    class GroupDetail < Group
251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
      expose :projects, using: Entities::Project do |group, options|
        GroupProjectsFinder.new(
          group: group,
          current_user: options[:current_user],
          options: { only_owned: true }
        ).execute
      end

      expose :shared_projects, using: Entities::Project do |group, options|
        GroupProjectsFinder.new(
          group: group,
          current_user: options[:current_user],
          options: { only_shared: true }
        ).execute
      end
266 267
    end

268
    class Commit < Grape::Entity
269 270 271 272 273 274 275
      expose :id, :short_id, :title, :created_at
      expose :parent_ids
      expose :safe_message, as: :message
      expose :author_name, :author_email, :authored_date
      expose :committer_name, :committer_email, :committed_date
    end

276
    class CommitStats < Grape::Entity
277 278 279
      expose :additions, :deletions, :total
    end

280 281
    class CommitDetail < Commit
      expose :stats, using: Entities::CommitStats
282
      expose :status
283
      expose :last_pipeline, using: 'API::Entities::PipelineBasic'
284 285
    end

286
    class Branch < Grape::Entity
287 288
      expose :name

289
      expose :commit, using: Entities::Commit do |repo_branch, options|
290
        options[:project].repository.commit(repo_branch.dereferenced_target)
291 292
      end

293
      expose :merged do |repo_branch, options|
294 295 296 297 298
        if options[:merged_branch_names]
          options[:merged_branch_names].include?(repo_branch.name)
        else
          options[:project].repository.merged_to_root_ref?(repo_branch)
        end
299 300
      end

301
      expose :protected do |repo_branch, options|
302
        ::ProtectedBranch.protected?(options[:project], repo_branch.name)
303 304
      end

305
      expose :developers_can_push do |repo_branch, options|
306
        options[:project].protected_branches.developers_can?(:push, repo_branch.name)
307
      end
308

309
      expose :developers_can_merge do |repo_branch, options|
310
        options[:project].protected_branches.developers_can?(:merge, repo_branch.name)
311
      end
Nihad Abbasov committed
312
    end
Nihad Abbasov committed
313

314
    class TreeObject < Grape::Entity
315
      expose :id, :name, :type, :path
316 317

      expose :mode do |obj, options|
318
        filemode = obj.mode
319 320 321 322 323
        filemode = "0" + filemode if filemode.length < 6
        filemode
      end
    end

Nihad Abbasov committed
324
    class ProjectSnippet < Grape::Entity
325
      expose :id, :title, :file_name, :description
326
      expose :author, using: Entities::UserBasic
327
      expose :updated_at, :created_at
328

329 330 331
      expose :web_url do |snippet, options|
        Gitlab::UrlBuilder.build(snippet)
      end
Nihad Abbasov committed
332
    end
Nihad Abbasov committed
333

334
    class PersonalSnippet < Grape::Entity
335
      expose :id, :title, :file_name, :description
336 337 338 339 340 341 342 343 344 345 346
      expose :author, using: Entities::UserBasic
      expose :updated_at, :created_at

      expose :web_url do |snippet|
        Gitlab::UrlBuilder.build(snippet)
      end
      expose :raw_url do |snippet|
        Gitlab::UrlBuilder.build(snippet) + "/raw"
      end
    end

347 348
    class ProjectEntity < Grape::Entity
      expose :id, :iid
Felipe Artur committed
349
      expose(:project_id) { |entity| entity&.project.try(:id) }
350 351
      expose :title, :description
      expose :state, :created_at, :updated_at
352 353
    end

354
    class Diff < Grape::Entity
355
      expose :old_path, :new_path, :a_mode, :b_mode
356 357 358
      expose :new_file?, as: :new_file
      expose :renamed_file?, as: :renamed_file
      expose :deleted_file?, as: :deleted_file
359
      expose :json_safe_diff, as: :diff
360 361
    end

362 363 364 365 366 367 368 369 370 371 372 373 374
    class ProtectedRefAccess < Grape::Entity
      expose :access_level
      expose :access_level_description do |protected_ref_access|
        protected_ref_access.humanize
      end
    end

    class ProtectedBranch < Grape::Entity
      expose :name
      expose :push_access_levels, using: Entities::ProtectedRefAccess
      expose :merge_access_levels, using: Entities::ProtectedRefAccess
    end

Felipe Artur committed
375 376
    class Milestone < Grape::Entity
      expose :id, :iid
377 378
      expose :project_id, if: -> (entity, options) { entity&.project_id }
      expose :group_id, if: -> (entity, options) { entity&.group_id }
Felipe Artur committed
379 380
      expose :title, :description
      expose :state, :created_at, :updated_at
381
      expose :due_date
382
      expose :start_date
Nihad Abbasov committed
383 384
    end

385
    class IssueBasic < ProjectEntity
386
      expose :closed_at
387 388 389 390
      expose :labels do |issue, options|
        # Avoids an N+1 query since labels are preloaded
        issue.labels.map(&:title).sort
      end
391
      expose :milestone, using: Entities::Milestone
392 393 394 395 396
      expose :assignees, :author, using: Entities::UserBasic

      expose :assignee, using: ::API::Entities::UserBasic do |issue, options|
        issue.assignees.first
      end
397

398
      expose :user_notes_count
399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414
      expose :upvotes do |issue, options|
        if options[:issuable_metadata]
          # Avoids an N+1 query when metadata is included
          options[:issuable_metadata][issue.id].upvotes
        else
          issue.upvotes
        end
      end
      expose :downvotes do |issue, options|
        if options[:issuable_metadata]
          # Avoids an N+1 query when metadata is included
          options[:issuable_metadata][issue.id].downvotes
        else
          issue.downvotes
        end
      end
415
      expose :due_date
416
      expose :confidential
417
      expose :discussion_locked
418 419 420 421

      expose :web_url do |issue, options|
        Gitlab::UrlBuilder.build(issue)
      end
422 423 424 425

      expose :time_stats, using: 'API::Entities::IssuableTimeStats' do |issue|
        issue
      end
Nihad Abbasov committed
426
    end
Alex Denisov committed
427

428
    class Issue < IssueBasic
429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448
      include ::API::Helpers::RelatedResourcesHelpers

      expose :_links do
        expose :self do |issue|
          expose_url(api_v4_project_issue_path(id: issue.project_id, issue_iid: issue.iid))
        end

        expose :notes do |issue|
          expose_url(api_v4_projects_issues_notes_path(id: issue.project_id, noteable_id: issue.iid))
        end

        expose :award_emoji do |issue|
          expose_url(api_v4_projects_issues_award_emoji_path(id: issue.project_id, issue_iid: issue.iid))
        end

        expose :project do |issue|
          expose_url(api_v4_projects_path(id: issue.project_id))
        end
      end

449 450 451 452 453
      expose :subscribed do |issue, options|
        issue.subscribed?(options[:current_user], options[:project] || issue.project)
      end
    end

454
    class IssuableTimeStats < Grape::Entity
455 456 457 458
      format_with(:time_tracking_formatter) do |time_spent|
        Gitlab::TimeTrackingFormatter.output(time_spent)
      end

459 460 461
      expose :time_estimate
      expose :total_time_spent
      expose :human_time_estimate
462 463 464 465 466 467 468 469 470

      with_options(format_with: :time_tracking_formatter) do
        expose :total_time_spent, as: :human_total_time_spent
      end

      def total_time_spent
        # Avoids an N+1 query since timelogs are preloaded
        object.timelogs.map(&:time_spent).sum
      end
471 472
    end

473 474 475 476 477
    class ExternalIssue < Grape::Entity
      expose :title
      expose :id
    end

478 479 480 481 482 483 484
    class MergeRequestSimple < ProjectEntity
      expose :title
      expose :web_url do |merge_request, options|
        Gitlab::UrlBuilder.build(merge_request)
      end
    end

485
    class MergeRequestBasic < ProjectEntity
Valery Sizov committed
486
      expose :target_branch, :source_branch
487 488 489 490 491 492 493 494 495 496 497 498 499 500
      expose :upvotes do |merge_request, options|
        if options[:issuable_metadata]
          options[:issuable_metadata][merge_request.id].upvotes
        else
          merge_request.upvotes
        end
      end
      expose :downvotes do |merge_request, options|
        if options[:issuable_metadata]
          options[:issuable_metadata][merge_request.id].downvotes
        else
          merge_request.downvotes
        end
      end
501 502
      expose :author, :assignee, using: Entities::UserBasic
      expose :source_project_id, :target_project_id
503 504 505 506
      expose :labels do |merge_request, options|
        # Avoids an N+1 query since labels are preloaded
        merge_request.labels.map(&:title).sort
      end
507
      expose :work_in_progress?, as: :work_in_progress
508
      expose :milestone, using: Entities::Milestone
509
      expose :merge_when_pipeline_succeeds
510
      expose :merge_status
511 512
      expose :diff_head_sha, as: :sha
      expose :merge_commit_sha
513
      expose :user_notes_count
514
      expose :discussion_locked
515 516
      expose :should_remove_source_branch?, as: :should_remove_source_branch
      expose :force_remove_source_branch?, as: :force_remove_source_branch
517 518 519 520

      expose :web_url do |merge_request, options|
        Gitlab::UrlBuilder.build(merge_request)
      end
521 522 523 524

      expose :time_stats, using: 'API::Entities::IssuableTimeStats' do |merge_request|
        merge_request
      end
Alex Denisov committed
525
    end
526

527 528 529 530
    class MergeRequest < MergeRequestBasic
      expose :subscribed do |merge_request, options|
        merge_request.subscribed?(options[:current_user], options[:project])
      end
531 532 533 534

      expose :changes_count do |merge_request, _options|
        merge_request.merge_request_diff.real_size
      end
535 536
    end

537
    class MergeRequestChanges < MergeRequest
538
      expose :diffs, as: :changes, using: Entities::Diff do |compare, _|
539
        compare.raw_diffs(limits: false).to_a
540 541 542
      end
    end

543 544 545
    class MergeRequestDiff < Grape::Entity
      expose :id, :head_commit_sha, :base_commit_sha, :start_commit_sha,
        :created_at, :merge_request_id, :state, :real_size
546
    end
547

548
    class MergeRequestDiffFull < MergeRequestDiff
549
      expose :commits, using: Entities::Commit
550

551
      expose :diffs, using: Entities::Diff do |compare, _|
552
        compare.raw_diffs(limits: false).to_a
553 554 555
      end
    end

556
    class SSHKey < Grape::Entity
557
      expose :id, :title, :key, :created_at, :can_push
558
    end
559

560
    class SSHKeyWithUser < SSHKey
561
      expose :user, using: Entities::UserPublic
562 563
    end

564 565 566 567
    class GPGKey < Grape::Entity
      expose :id, :key, :created_at
    end

568
    class Note < Grape::Entity
sue445 committed
569 570 571
      # Only Issue and MergeRequest have iid
      NOTEABLE_TYPES_WITH_IID = %w(Issue MergeRequest).freeze

572 573
      expose :id
      expose :note, as: :body
574
      expose :attachment_identifier, as: :attachment
575
      expose :author, using: Entities::UserBasic
576
      expose :created_at, :updated_at
577
      expose :system?, as: :system
578
      expose :noteable_id, :noteable_type
sue445 committed
579 580 581

      # Avoid N+1 queries as much as possible
      expose(:noteable_iid) { |note| note.noteable.iid if NOTEABLE_TYPES_WITH_IID.include?(note.noteable_type) }
582
    end
583

584 585 586 587 588 589 590 591
    class AwardEmoji < Grape::Entity
      expose :id
      expose :name
      expose :user, using: Entities::UserBasic
      expose :created_at, :updated_at
      expose :awardable_id, :awardable_type
    end

592 593 594 595
    class MRNote < Grape::Entity
      expose :note
      expose :author, using: Entities::UserBasic
    end
596

597 598
    class CommitNote < Grape::Entity
      expose :note
599 600 601
      expose(:path) { |note| note.diff_file.try(:file_path) if note.diff_note? }
      expose(:line) { |note| note.diff_line.try(:new_line) if note.diff_note? }
      expose(:line_type) { |note| note.diff_line.try(:type) if note.diff_note? }
602
      expose :author, using: Entities::UserBasic
603
      expose :created_at
604 605
    end

606 607
    class CommitStatus < Grape::Entity
      expose :id, :sha, :ref, :status, :name, :target_url, :description,
608
             :created_at, :started_at, :finished_at, :allow_failure, :coverage
609
      expose :author, using: Entities::UserBasic
610 611
    end

612 613 614 615 616
    class PushEventPayload < Grape::Entity
      expose :commit_count, :action, :ref_type, :commit_from, :commit_to
      expose :ref, :commit_title
    end

617
    class Event < Grape::Entity
618
      expose :project_id, :action_name
619
      expose :target_id, :target_iid, :target_type, :author_id
620
      expose :target_title
621
      expose :created_at
622 623
      expose :note, using: Entities::Note, if: ->(event, options) { event.note? }
      expose :author, using: Entities::UserBasic, if: ->(event, options) { event.author }
624

625 626 627 628 629
      expose :push_event_payload,
        as: :push_data,
        using: PushEventPayload,
        if: -> (event, _) { event.push? }

630
      expose :author_username do |event, options|
631
        event.author&.username
632
      end
633
    end
634

635
    class ProjectGroupLink < Grape::Entity
636
      expose :id, :project_id, :group_id, :group_access, :expires_at
637 638
    end

639 640 641 642
    class Todo < Grape::Entity
      expose :id
      expose :project, using: Entities::BasicProjectDetails
      expose :author, using: Entities::UserBasic
Robert Schilling committed
643
      expose :action_name
644
      expose :target_type
645 646

      expose :target do |todo, options|
647
        Entities.const_get(todo.target_type).represent(todo.target, options)
648 649 650 651 652
      end

      expose :target_url do |todo, options|
        target_type   = todo.target_type.underscore
        target_url    = "namespace_project_#{target_type}_url"
653
        target_anchor = "note_#{todo.note_id}" if todo.note_id?
654

655 656 657
        Gitlab::Routing
          .url_helpers
          .public_send(target_url, todo.project.namespace, todo.project, todo.target, anchor: target_anchor) # rubocop:disable GitlabSecurity/PublicSend
658 659 660 661 662 663 664
      end

      expose :body
      expose :state
      expose :created_at
    end

665
    class NamespaceBasic < Grape::Entity
666
      expose :id, :name, :path, :kind, :full_path, :parent_id
667
    end
668

669
    class Namespace < NamespaceBasic
670 671 672 673 674 675
      expose :members_count_with_descendants, if: -> (namespace, opts) { expose_members_count_with_descendants?(namespace, opts) } do |namespace, _|
        namespace.users_with_descendants.count
      end

      def expose_members_count_with_descendants?(namespace, opts)
        namespace.kind == 'group' && Ability.allowed?(opts[:current_user], :admin_group, namespace)
676
      end
677
    end
678

679
    class MemberAccess < Grape::Entity
680
      expose :access_level
681
      expose :notification_level do |member, options|
682 683 684
        if member.notification_setting
          ::NotificationSetting.levels[member.notification_setting.level]
        end
685
      end
686 687
    end

688
    class ProjectAccess < MemberAccess
689 690
    end

691
    class GroupAccess < MemberAccess
692 693
    end

694 695 696 697 698 699 700 701 702 703 704 705 706 707 708
    class NotificationSetting < Grape::Entity
      expose :level
      expose :events, if: ->(notification_setting, _) { notification_setting.custom? } do
        ::NotificationSetting::EMAIL_EVENTS.each do |event|
          expose event
        end
      end
    end

    class GlobalNotificationSetting < NotificationSetting
      expose :notification_email do |notification_setting, options|
        notification_setting.user.notification_email
      end
    end

709 710
    class ProjectService < Grape::Entity
      expose :id, :title, :created_at, :updated_at, :active
711
      expose :push_events, :issues_events, :merge_requests_events
712
      expose :tag_push_events, :note_events, :pipeline_events
713
      expose :job_events
714 715
      # Expose serialized properties
      expose :properties do |service, options|
716 717 718
        field_names = service.fields
          .select { |field| options[:include_passwords] || field[:type] != 'password' }
          .map { |field| field[:name] }
719 720 721 722
        service.properties.slice(*field_names)
      end
    end

723 724 725
    class ProjectWithAccess < Project
      expose :permissions do
        expose :project_access, using: Entities::ProjectAccess do |project, options|
726
          if options.key?(:project_members)
727 728 729
            (options[:project_members] || []).find { |member| member.source_id == project.id }
          else
            project.project_member(options[:current_user])
730
          end
731 732 733
        end

        expose :group_access, using: Entities::GroupAccess do |project, options|
734
          if project.group
735
            if options.key?(:group_members)
736 737 738
              (options[:group_members] || []).find { |member| member.source_id == project.namespace_id }
            else
              project.group.group_member(options[:current_user])
739
            end
740
          end
741 742
        end
      end
743 744 745 746 747 748 749 750 751 752 753 754 755 756

      def self.preload_relation(projects_relation, options = {})
        relation = super(projects_relation, options)

        unless options.key?(:group_members)
          relation = relation.preload(group: [group_members: [:source, user: [notification_settings: :source]]])
        end

        unless options.key?(:project_members)
          relation = relation.preload(project_members: [:source, user: [notification_settings: :source]])
        end

        relation
      end
757
    end
758

759
    class LabelBasic < Grape::Entity
760
      expose :id, :name, :color, :description
761 762 763
    end

    class Label < LabelBasic
764
      expose :open_issues_count do |label, options|
765 766
        label.open_issues_count(options[:current_user])
      end
767

768 769 770
      expose :closed_issues_count do |label, options|
        label.closed_issues_count(options[:current_user])
      end
771

772 773
      expose :open_merge_requests_count do |label, options|
        label.open_merge_requests_count(options[:current_user])
774 775
      end

776 777 778
      expose :priority do |label, options|
        label.priority(options[:project])
      end
779 780

      expose :subscribed do |label, options|
781
        label.subscribed?(options[:current_user], options[:project])
782
      end
783
    end
784

785 786 787 788 789 790 791 792 793 794 795 796 797
    class List < Grape::Entity
      expose :id
      expose :label, using: Entities::LabelBasic
      expose :position
    end

    class Board < Grape::Entity
      expose :id
      expose :lists, using: Entities::List do |board|
        board.lists.destroyable
      end
    end

798
    class Compare < Grape::Entity
799 800
      expose :commit, using: Entities::Commit do |compare, options|
        ::Commit.decorate(compare.commits, nil).last
801
      end
802

803 804
      expose :commits, using: Entities::Commit do |compare, options|
        ::Commit.decorate(compare.commits, nil)
805
      end
806

807
      expose :diffs, using: Entities::Diff do |compare, options|
808
        compare.diffs(limits: false).to_a
809
      end
810 811

      expose :compare_timeout do |compare, options|
812
        compare.diffs.overflow?
813 814 815
      end

      expose :same, as: :compare_same_ref
816
    end
817 818 819 820

    class Contributor < Grape::Entity
      expose :name, :email, :commits, :additions, :deletions
    end
821 822 823 824

    class BroadcastMessage < Grape::Entity
      expose :message, :starts_at, :ends_at, :color, :font
    end
825 826 827

    class ApplicationSetting < Grape::Entity
      expose :id
828
      expose(*::ApplicationSettingsHelper.visible_attributes)
829 830 831 832 833 834
      expose(:restricted_visibility_levels) do |setting, _options|
        setting.restricted_visibility_levels.map { |level| Gitlab::VisibilityLevel.string_level(level) }
      end
      expose(:default_project_visibility) { |setting, _options| Gitlab::VisibilityLevel.string_level(setting.default_project_visibility) }
      expose(:default_snippet_visibility) { |setting, _options| Gitlab::VisibilityLevel.string_level(setting.default_snippet_visibility) }
      expose(:default_group_visibility) { |setting, _options| Gitlab::VisibilityLevel.string_level(setting.default_group_visibility) }
835 836 837 838

      # support legacy names, can be removed in v5
      expose :password_authentication_enabled_for_web, as: :password_authentication_enabled
      expose :password_authentication_enabled_for_web, as: :signin_enabled
839
    end
Dmitriy Zaporozhets committed
840 841

    class Release < Grape::Entity
842 843
      expose :tag, as: :tag_name
      expose :description
Dmitriy Zaporozhets committed
844
    end
845

846
    class Tag < Grape::Entity
847
      expose :name, :message
848

849
      expose :commit, using: Entities::Commit do |repo_tag, options|
850
        options[:project].repository.commit(repo_tag.dereferenced_target)
851 852
      end

853 854
      expose :release, using: Entities::Release do |repo_tag, options|
        options[:project].releases.find_by(tag: repo_tag.name)
855 856
      end
    end
857

858
    class Runner < Grape::Entity
859 860 861 862 863 864 865
      expose :id
      expose :description
      expose :active
      expose :is_shared
      expose :name
    end

866 867
    class RunnerDetails < Runner
      expose :tag_list
868
      expose :run_untagged
869
      expose :locked
Shinya Maeda committed
870
      expose :access_level
871
      expose :version, :revision, :platform, :architecture
872
      expose :contacted_at
873
      expose :token, if: lambda { |runner, options| options[:current_user].admin? || !runner.is_shared? }
874
      expose :projects, with: Entities::BasicProjectDetails do |runner, options|
875
        if options[:current_user].admin?
876 877
          runner.projects
        else
878
          options[:current_user].authorized_projects.where(id: runner.projects)
879 880
        end
      end
881 882
    end

883 884 885 886
    class RunnerRegistrationDetails < Grape::Entity
      expose :id, :token
    end

887
    class JobArtifactFile < Grape::Entity
888 889 890
      expose :filename, :size
    end

891 892 893 894
    class PipelineBasic < Grape::Entity
      expose :id, :sha, :ref, :status
    end

Tomasz Maczukin committed
895
    class JobBasic < Grape::Entity
896
      expose :id, :status, :stage, :name, :ref, :tag, :coverage
897
      expose :created_at, :started_at, :finished_at
898
      expose :duration
Tomasz Maczukin committed
899
      expose :user, with: User
900
      expose :commit, with: Commit
901
      expose :pipeline, with: PipelineBasic
902
    end
903

Tomasz Maczukin committed
904 905 906 907 908 909
    class Job < JobBasic
      expose :artifacts_file, using: JobArtifactFile, if: -> (job, opts) { job.artifacts? }
      expose :runner, with: Runner
    end

    class JobBasicWithProject < JobBasic
910 911 912
      expose :project, with: ProjectIdentity
    end

913
    class Trigger < Grape::Entity
914
      expose :id
915 916 917
      expose :token, :description
      expose :created_at, :updated_at, :deleted_at, :last_used
      expose :owner, using: Entities::UserBasic
918
    end
919

920
    class Variable < Grape::Entity
Tomasz Maczukin committed
921
      expose :key, :value
922
      expose :protected?, as: :protected, if: -> (entity, _) { entity.respond_to?(:protected?) }
923
    end
924

925 926
    class Pipeline < PipelineBasic
      expose :before_sha, :tag, :yaml_errors
927 928 929 930

      expose :user, with: Entities::UserBasic
      expose :created_at, :updated_at, :started_at, :finished_at, :committed_at
      expose :duration
931
      expose :coverage
932 933
    end

934 935 936
    class PipelineSchedule < Grape::Entity
      expose :id
      expose :description, :ref, :cron, :cron_timezone, :next_run_at, :active
937
      expose :created_at, :updated_at
938 939 940
      expose :owner, using: Entities::UserBasic
    end

941 942
    class PipelineScheduleDetails < PipelineSchedule
      expose :last_pipeline, using: Entities::PipelineBasic
943
      expose :variables, using: Entities::Variable
944 945
    end

946
    class EnvironmentBasic < Grape::Entity
Nick Thomas committed
947
      expose :id, :name, :slug, :external_url
948 949
    end

950
    class Environment < EnvironmentBasic
951
      expose :project, using: Entities::BasicProjectDetails
952 953 954 955
    end

    class Deployment < Grape::Entity
      expose :id, :iid, :ref, :sha, :created_at
956 957
      expose :user,        using: Entities::UserBasic
      expose :environment, using: Entities::EnvironmentBasic
958
      expose :deployable,  using: Entities::Job
959 960
    end

961
    class License < Grape::Entity
962 963
      expose :key, :name, :nickname
      expose :featured, as: :popular
964 965 966
      expose :url, as: :html_url
      expose(:source_url) { |license| license.meta['source'] }
      expose(:description) { |license| license.meta['description'] }
967 968 969
      expose(:conditions) { |license| license.meta['conditions'] }
      expose(:permissions) { |license| license.meta['permissions'] }
      expose(:limitations) { |license| license.meta['limitations'] }
970 971
      expose :content
    end
972

973
    class TemplatesList < Grape::Entity
974 975 976
      expose :name
    end

977
    class Template < Grape::Entity
978 979
      expose :name, :content
    end
980 981 982 983 984

    class BroadcastMessage < Grape::Entity
      expose :id, :message, :starts_at, :ends_at, :color, :font
      expose :active?, as: :active
    end
985

986
    class PersonalAccessToken < Grape::Entity
987 988 989 990 991 992 993
      expose :id, :name, :revoked, :created_at, :scopes
      expose :active?, as: :active
      expose :expires_at do |personal_access_token|
        personal_access_token.expires_at ? personal_access_token.expires_at.strftime("%Y-%m-%d") : nil
      end
    end

994
    class PersonalAccessTokenWithToken < PersonalAccessToken
995 996
      expose :token
    end
997 998 999 1000

    class ImpersonationToken < PersonalAccessTokenWithToken
      expose :impersonation
    end
1001

1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
    class FeatureGate < Grape::Entity
      expose :key
      expose :value
    end

    class Feature < Grape::Entity
      expose :name
      expose :state
      expose :gates, using: FeatureGate do |model|
        model.gates.map do |gate|
          value = model.gate_values[gate.key]

          # By default all gate values are populated. Only show relevant ones.
          if (value.is_a?(Integer) && value.zero?) || (value.is_a?(Set) && value.empty?)
            next
          end

          { key: gate.key, value: value }
        end.compact
      end
    end

1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039
    module JobRequest
      class JobInfo < Grape::Entity
        expose :name, :stage
        expose :project_id, :project_name
      end

      class GitInfo < Grape::Entity
        expose :repo_url, :ref, :sha, :before_sha
        expose :ref_type do |model|
          if model.tag
            'tag'
          else
            'branch'
          end
        end
      end
1040

1041 1042 1043
      class RunnerInfo < Grape::Entity
        expose :timeout
      end
1044

1045
      class Step < Grape::Entity
1046
        expose :name, :script, :timeout, :when, :allow_failure
1047
      end
1048

1049
      class Image < Grape::Entity
1050 1051 1052
        expose :name, :entrypoint
      end

1053
      class Service < Image
1054
        expose :alias, :command
1055
      end
1056

1057 1058
      class Artifacts < Grape::Entity
        expose :name, :untracked, :paths, :when, :expire_in
1059 1060
      end

1061
      class Cache < Grape::Entity
1062
        expose :key, :untracked, :paths, :policy
1063 1064
      end

1065 1066 1067
      class Credentials < Grape::Entity
        expose :type, :url, :username, :password
      end
1068

1069
      class Dependency < Grape::Entity
1070
        expose :id, :name, :token
1071
        expose :artifacts_file, using: JobArtifactFile, if: ->(job, _) { job.artifacts? }
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
      end

      class Response < Grape::Entity
        expose :id
        expose :token
        expose :allow_git_fetch

        expose :job_info, using: JobInfo do |model|
          model
        end

        expose :git_info, using: GitInfo do |model|
          model
        end

        expose :runner_info, using: RunnerInfo do |model|
          model
        end

        expose :variables
        expose :steps, using: Step
        expose :image, using: Image
1094
        expose :services, using: Service
1095 1096 1097
        expose :artifacts, using: Artifacts
        expose :cache, using: Cache
        expose :credentials, using: Credentials
1098
        expose :dependencies, using: Dependency
1099
        expose :features
1100
      end
1101
    end
1102 1103 1104 1105

    class UserAgentDetail < Grape::Entity
      expose :user_agent
      expose :ip_address
1106
      expose :submitted, as: :akismet_submitted
1107
    end
1108 1109 1110 1111 1112 1113

    class RepositoryStorageHealth < Grape::Entity
      expose :storage_name
      expose :failing_on_hosts
      expose :total_failures
    end
1114 1115 1116 1117 1118

    class CustomAttribute < Grape::Entity
      expose :key
      expose :value
    end
1119

1120 1121 1122 1123 1124
    class PagesDomainCertificateExpiration < Grape::Entity
      expose :expired?, as: :expired
      expose :expiration
    end

1125 1126 1127 1128 1129 1130 1131
    class PagesDomainCertificate < Grape::Entity
      expose :subject
      expose :expired?, as: :expired
      expose :certificate
      expose :certificate_text
    end

1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
    class PagesDomainBasic < Grape::Entity
      expose :domain
      expose :url
      expose :certificate,
        as: :certificate_expiration,
        if: ->(pages_domain, _) { pages_domain.certificate? },
        using: PagesDomainCertificateExpiration do |pages_domain|
        pages_domain
      end
    end

1143 1144 1145 1146
    class PagesDomain < Grape::Entity
      expose :domain
      expose :url
      expose :certificate,
1147 1148
        if: ->(pages_domain, _) { pages_domain.certificate? },
        using: PagesDomainCertificate do |pages_domain|
1149 1150 1151
        pages_domain
      end
    end
Nihad Abbasov committed
1152 1153
  end
end