Merge branch 'sh-support-bitbucket-server-import' into 'master'

Add support for Bitbucket Server imports

Closes #25393

See merge request gitlab-org/gitlab-ce!20164

app/assets/javascripts/importer_status.js

@@ -36,6 +36,8 @@ class ImporterStatus {
     const $targetField = $tr.find('.import-target');
     const $namespaceInput = $targetField.find('.js-select-namespace option:selected');
     const id = $tr.attr('id').replace('repo_', '');
+    const repoData = $tr.data();
+
     let targetNamespace;
     let newName;
     if ($namespaceInput.length > 0) {
@@ -45,12 +47,20 @@ class ImporterStatus {
     }
     $btn.disable().addClass('is-loading');
-    return axios.post(this.importUrl, {
+    this.id = id;
+
+    let attributes = {
       repo_id: id,
       target_namespace: targetNamespace,
       new_name: newName,
       ci_cd_only: this.ciCdOnly,
-    })
+    };
+
+    if (repoData) {
+      attributes = Object.assign(repoData, attributes);
+    }
+
+    return axios.post(this.importUrl, attributes)
     .then(({ data }) => {
       const job = $(`tr#repo_${id}`);
       job.attr('id', `project_${data.id}`);
@@ -70,6 +80,9 @@ class ImporterStatus {
     .catch((error) => {
       let details = error;
+      const $statusField = $(`#repo_${this.id} .job-status`);
+      $statusField.text(__('Failed'));
+
       if (error.response && error.response.data && error.response.data.errors) {
         details = error.response.data.errors;
       }

app/controllers/application_controller.rb

@@ -35,6 +35,7 @@ class ApplicationController < ActionController::Base
     :gitea_import_enabled?, :github_import_configured?,
     :gitlab_import_enabled?, :gitlab_import_configured?,
     :bitbucket_import_enabled?, :bitbucket_import_configured?,
+    :bitbucket_server_import_enabled?,
     :google_code_import_enabled?, :fogbugz_import_enabled?,
     :git_import_enabled?, :gitlab_project_import_enabled?,
     :manifest_import_enabled?
@@ -337,6 +338,10 @@ class ApplicationController < ActionController::Base
     !Gitlab::CurrentSettings.import_sources.empty?
   end
+  def bitbucket_server_import_enabled?
+    Gitlab::CurrentSettings.import_sources.include?('bitbucket_server')
+  end
+
   def github_import_enabled?
     Gitlab::CurrentSettings.import_sources.include?('github')
   end

app/controllers/import/bitbucket_server_controller.rb

+# frozen_string_literal: true
+
+class Import::BitbucketServerController < Import::BaseController
+  before_action :verify_bitbucket_server_import_enabled
+  before_action :bitbucket_auth, except: [:new, :configure]
+  before_action :validate_import_params, only: [:create]
+
+  # As a basic sanity check to prevent URL injection, restrict project
+  # repository input and repository slugs to allowed characters. For Bitbucket:
+  #
+  # Project keys must start with a letter and may only consist of ASCII letters, numbers and underscores (A-Z, a-z, 0-9, _).
+  #
+  # Repository names are limited to 128 characters. They must start with a
+  # letter or number and may contain spaces, hyphens, underscores, and periods.
+  # (https://community.atlassian.com/t5/Answers-Developer-Questions/stash-repository-names/qaq-p/499054)
+  VALID_BITBUCKET_CHARS = /\A[\w\-_\.\s]+\z/
+
+  def new
+  end
+
+  def create
+    repo = bitbucket_client.repo(@project_key, @repo_slug)
+
+    unless repo
+      return render json: { errors: "Project #{@project_key}/#{@repo_slug} could not be found" }, status: :unprocessable_entity
+    end
+
+    project_name = params[:new_name].presence || repo.name
+    namespace_path = params[:new_namespace].presence || current_user.username
+    target_namespace = find_or_create_namespace(namespace_path, current_user)
+
+    if current_user.can?(:create_projects, target_namespace)
+      project = Gitlab::BitbucketServerImport::ProjectCreator.new(@project_key, @repo_slug, repo, project_name, target_namespace, current_user, credentials).execute
+
+      if project.persisted?
+        render json: ProjectSerializer.new.represent(project)
+      else
+        render json: { errors: project_save_error(project) }, status: :unprocessable_entity
+      end
+    else
+      render json: { errors: 'This namespace has already been taken! Please choose another one.' }, status: :unprocessable_entity
+    end
+  rescue BitbucketServer::Client::ServerError => e
+    render json: { errors: "Unable to connect to server: #{e}" }, status: :unprocessable_entity
+  end
+
+  def configure
+    session[personal_access_token_key] = params[:personal_access_token]
+    session[bitbucket_server_username_key] = params[:bitbucket_username]
+    session[bitbucket_server_url_key] = params[:bitbucket_server_url]
+
+    redirect_to status_import_bitbucket_server_path
+  end
+
+  def status
+    repos = bitbucket_client.repos
+
+    @repos, @incompatible_repos = repos.partition { |repo| repo.valid? }
+
+    @already_added_projects = find_already_added_projects('bitbucket_server')
+    already_added_projects_names = @already_added_projects.pluck(:import_source)
+
+    @repos.to_a.reject! { |repo| already_added_projects_names.include?(repo.browse_url) }
+  rescue BitbucketServer::Connection::ConnectionError, BitbucketServer::Client::ServerError => e
+    flash[:alert] = "Unable to connect to server: #{e}"
+    clear_session_data
+    redirect_to new_import_bitbucket_server_path
+  end
+
+  def jobs
+    render json: find_jobs('bitbucket_server')
+  end
+
+  private
+
+  def bitbucket_client
+    @bitbucket_client ||= BitbucketServer::Client.new(credentials)
+  end
+
+  def validate_import_params
+    @project_key = params[:project]
+    @repo_slug = params[:repository]
+
+    return render_validation_error('Missing project key') unless @project_key.present? && @repo_slug.present?
+    return render_validation_error('Missing repository slug') unless @repo_slug.present?
+    return render_validation_error('Invalid project key') unless @project_key =~ VALID_BITBUCKET_CHARS
+    return render_validation_error('Invalid repository slug') unless @repo_slug =~ VALID_BITBUCKET_CHARS
+  end
+
+  def render_validation_error(message)
+    render json: { errors: message }, status: :unprocessable_entity
+  end
+
+  def bitbucket_auth
+    unless session[bitbucket_server_url_key].present? &&
+        session[bitbucket_server_username_key].present? &&
+        session[personal_access_token_key].present?
+      redirect_to new_import_bitbucket_server_path
+    end
+  end
+
+  def verify_bitbucket_server_import_enabled
+    render_404 unless bitbucket_server_import_enabled?
+  end
+
+  def bitbucket_server_url_key
+    :bitbucket_server_url
+  end
+
+  def bitbucket_server_username_key
+    :bitbucket_server_username
+  end
+
+  def personal_access_token_key
+    :bitbucket_server_personal_access_token
+  end
+
+  def clear_session_data
+    session[bitbucket_server_url_key] = nil
+    session[bitbucket_server_username_key] = nil
+    session[personal_access_token_key] = nil
+  end
+
+  def credentials
+    {
+      base_uri: session[bitbucket_server_url_key],
+      user: session[bitbucket_server_username_key],
+      password: session[personal_access_token_key]
+    }
+  end
+end

app/helpers/namespaces_helper.rb

@@ -9,13 +9,23 @@ module NamespacesHelper
                .includes(:route)
                .order('routes.path')
     users = [current_user.namespace]
+    selected_id = selected
     unless extra_group.nil? || extra_group.is_a?(Group)
       extra_group = Group.find(extra_group) if Namespace.find(extra_group).kind == 'group'
     end
-    if extra_group && extra_group.is_a?(Group) && (!Group.exists?(name: extra_group.name) || Ability.allowed?(current_user, :read_group, extra_group))
-      groups |= [extra_group]
+    if extra_group && extra_group.is_a?(Group)
+      extra_group = dedup_extra_group(extra_group)
+
+      if Ability.allowed?(current_user, :read_group, extra_group)
+        # Assign the value to an invalid primary ID so that the select box works
+        extra_group.id = -1 unless extra_group.persisted?
+        selected_id = extra_group.id if selected == :extra_group
+        groups |= [extra_group]
+      else
+        selected_id = current_user.namespace.id
+      end
     end
     options = []
@@ -25,11 +35,11 @@ module NamespacesHelper
       options << options_for_group(users, display_path: display_path, type: 'user')
       if selected == :current_user && current_user.namespace
-        selected = current_user.namespace.id
+        selected_id = current_user.namespace.id
       end
     end
-    grouped_options_for_select(options, selected)
+    grouped_options_for_select(options, selected_id)
   end
   def namespace_icon(namespace, size = 40)
@@ -42,6 +52,17 @@ module NamespacesHelper
   private
+  # Many importers create a temporary Group, so use the real
+  # group if one exists by that name to prevent duplicates.
+  def dedup_extra_group(extra_group)
+    unless extra_group.persisted?
+      existing_group = Group.find_by(name: extra_group.name)
+      extra_group = existing_group if existing_group&.persisted?
+    end
+
+    extra_group
+  end
+
   def options_for_group(namespaces, display_path:, type:)
     group_label = type.pluralize
     elements = namespaces.sort_by(&:human_name).map! do |n|

app/models/project.rb

@@ -654,6 +654,8 @@ class Project < ActiveRecord::Base
       project_import_data.credentials ||= {}
       project_import_data.credentials = project_import_data.credentials.merge(credentials)
     end
+
+    project_import_data
   end
   def import?

app/views/import/bitbucket_server/new.html.haml

+- title = _('Bitbucket Server Import')
+- page_title title
+- breadcrumb_title title
+- header_title "Projects", root_path
+
+%h3.page-title
+  = icon 'bitbucket-square', text: _('Import repositories from Bitbucket Server')
+
+%p
+  = _('Enter in your Bitbucket Server URL and personal access token below')
+
+= form_tag configure_import_bitbucket_server_path, method: :post do
+  .form-group.row
+    = label_tag :bitbucket_server_url, 'Bitbucket Server URL', class: 'col-form-label col-md-2'
+    .col-md-4
+      = text_field_tag :bitbucket_server_url, '', class: 'form-control append-right-8', placeholder: _('https://your-bitbucket-server'), size: 40
+  .form-group.row
+    = label_tag :bitbucket_server_url, 'Username', class: 'col-form-label col-md-2'
+    .col-md-4
+      = text_field_tag :bitbucket_username, '', class: 'form-control append-right-8', placeholder: _('username'), size: 40
+  .form-group.row
+    = label_tag :personal_access_token, 'Password/Personal Access Token', class: 'col-form-label col-md-2'
+    .col-md-4
+      = password_field_tag :personal_access_token, '', class: 'form-control append-right-8', placeholder: _('Personal Access Token'), size: 40
+  .form-actions
+    = submit_tag _('List your Bitbucket Server repositories'), class: 'btn btn-success'

app/views/import/bitbucket_server/status.html.haml

+- page_title 'Bitbucket Server import'
+- header_title 'Projects', root_path
+
+%h3.page-title
+  %i.fa.fa-bitbucket-square
+  = _('Import projects from Bitbucket Server')
+
+- if @repos.any?
+  %p.light
+    = _('Select projects you want to import.')
+  .btn-group
+    - if @incompatible_repos.any?
+      = button_tag class: 'btn btn-import btn-success js-import-all' do
+        = _('Import all compatible projects')
+        = icon('spinner spin', class: 'loading-icon')
+    - else
+      = button_tag class: 'btn btn-import btn-success js-import-all' do
+        = _('Import all projects')
+        = icon('spinner spin', class: 'loading-icon')
+  .btn-group
+    = link_to('Reconfigure', configure_import_bitbucket_server_path, class: 'btn btn-primary', method: :post)
+
+.table-responsive.prepend-top-10
+  %table.table.import-jobs
+    %colgroup.import-jobs-from-col
+    %colgroup.import-jobs-to-col
+    %colgroup.import-jobs-status-col
+    %thead
+      %tr
+        %th= _('From Bitbucket Server')
+        %th= _('To GitLab')
+        %th= _(' Status')
+    %tbody
+      - @already_added_projects.each do |project|
+        %tr{ id: "project_#{project.id}", class: "#{project_status_css_class(project.import_status)}" }
+          %td
+            = link_to project.import_source, project.import_source, target: '_blank', rel: 'noopener noreferrer'
+          %td
+            = link_to project.full_path, [project.namespace.becomes(Namespace), project]
+          %td.job-status
+            - if project.import_status == 'finished'
+              = icon('check', text: 'Done')
+            - elsif project.import_status == 'started'
+              = icon('spin', text: 'started')
+            - else
+              = project.human_import_status_name
+
+      - @repos.each do |repo|
+        %tr{ id: "repo_#{repo.project_key}___#{repo.slug}", data: { project: repo.project_key, repository: repo.slug } }
+          %td
+            = link_to repo.browse_url, repo.browse_url, target: '_blank', rel: 'noopener noreferrer'
+          %td.import-target
+            %fieldset.row
+            .input-group
+              .project-path.input-group-prepend
+                - if current_user.can_select_namespace?
+                  - selected = params[:namespace_id] || :extra_group
+                  - opts = current_user.can_create_group? ? { extra_group: Group.new(name: repo.project_key, path: repo.project_key) } : {}
+                  = select_tag :namespace_id, namespaces_options(selected, opts.merge({ display_path: true })), { class: 'input-group-text select2 js-select-namespace', tabindex: 1 }
+                - else
+                  = text_field_tag :path, current_user.namespace_path, class: "input-group-text input-large form-control", tabindex: 1, disabled: true
+              %span.input-group-prepend
+                .input-group-text /
+              = text_field_tag :path, repo.name, class: "input-mini form-control", tabindex: 2, autofocus: true, required: true
+          %td.import-actions.job-status
+            = button_tag class: 'btn btn-import js-add-to-import' do
+              Import
+              = icon('spinner spin', class: 'loading-icon')
+      - @incompatible_repos.each do |repo|
+        %tr{ id: "repo_#{repo.project_key}___#{repo.slug}" }
+          %td
+            = link_to repo.browse_url, repo.browse_url, target: '_blank', rel: 'noopener noreferrer'
+          %td.import-target
+          %td.import-actions-job-status
+            = label_tag 'Incompatible Project', nil, class: 'label badge-danger'
+
+- if @incompatible_repos.any?
+  %p
+    One or more of your Bitbucket Server projects cannot be imported into GitLab
+    directly because they use Subversion or Mercurial for version control,
+    rather than Git. Please convert
+    = link_to 'them to Git,', 'https://www.atlassian.com/git/tutorials/migrating-overview'
+    and go through the
+    = link_to 'import flow', status_import_bitbucket_server_path
+    again.
+
+.js-importer-status{ data: { jobs_import_path: "#{jobs_import_bitbucket_server_path}", import_path: "#{import_bitbucket_server_path}" } }

app/views/projects/_import_project_pane.html.haml

@@ -18,10 +18,14 @@
       - if bitbucket_import_enabled?
         %div
           = link_to status_import_bitbucket_path, class: "btn import_bitbucket #{'how_to_import_link' unless bitbucket_import_configured?}" do
-            = icon('bitbucket', text: 'Bitbucket')
+            = icon('bitbucket', text: 'Bitbucket Cloud')
           - unless bitbucket_import_configured?
             = render 'bitbucket_import_modal'
-
+      - if bitbucket_server_import_enabled?
+        %div
+          = link_to status_import_bitbucket_server_path, class: "btn import_bitbucket" do
+            = icon('bitbucket-square', text: 'Bitbucket Server')
+        %div
       - if gitlab_import_enabled?
         %div
           = link_to status_import_gitlab_path, class: "btn import_gitlab #{'how_to_import_link' unless gitlab_import_configured?}" do

config/routes/import.rb

@@ -24,6 +24,13 @@ namespace :import do
     get :jobs
   end
+  resource :bitbucket_server, only: [:create, :new], controller: :bitbucket_server do
+    post :configure
+    get :status
+    get :callback
+    get :jobs
+  end
+
   resource :google_code, only: [:create, :new], controller: :google_code do
     get :status
     post :callback

lib/bitbucket_server/client.rb

+# frozen_string_literal: true
+
+module BitbucketServer
+  class Client
+    attr_reader :connection
+
+    ServerError = Class.new(StandardError)
+
+    SERVER_ERRORS = [SocketError,
+                     OpenSSL::SSL::SSLError,
+                     Errno::ECONNRESET,
+                     Errno::ECONNREFUSED,
+                     Errno::EHOSTUNREACH,
+                     Net::OpenTimeout,
+                     Net::ReadTimeout,
+                     Gitlab::HTTP::BlockedUrlError,
+                     BitbucketServer::Connection::ConnectionError].freeze
+
+    def initialize(options = {})
+      @connection = Connection.new(options)
+    end
+
+    def pull_requests(project_key, repo)
+      path = "/projects/#{project_key}/repos/#{repo}/pull-requests?state=ALL"
+      get_collection(path, :pull_request)
+    end
+
+    def activities(project_key, repo, pull_request_id)
+      path = "/projects/#{project_key}/repos/#{repo}/pull-requests/#{pull_request_id}/activities"
+      get_collection(path, :activity)
+    end
+
+    def repo(project, repo_name)
+      parsed_response = connection.get("/projects/#{project}/repos/#{repo_name}")
+      BitbucketServer::Representation::Repo.new(parsed_response)
+    end
+
+    def repos
+      path = "/repos"
+      get_collection(path, :repo)
+    end
+
+    def create_branch(project_key, repo, branch_name, sha)
+      payload = {
+        name: branch_name,
+        startPoint: sha,
+        message: 'GitLab temporary branch for import'
+      }
+
+      connection.post("/projects/#{project_key}/repos/#{repo}/branches", payload.to_json)
+    end
+
+    def delete_branch(project_key, repo, branch_name, sha)
+      payload = {
+        name: Gitlab::Git::BRANCH_REF_PREFIX + branch_name,
+        dryRun: false
+      }
+
+      connection.delete(:branches, "/projects/#{project_key}/repos/#{repo}/branches", payload.to_json)
+    end
+
+    private
+
+    def get_collection(path, type)
+      paginator = BitbucketServer::Paginator.new(connection, Addressable::URI.escape(path), type)
+      BitbucketServer::Collection.new(paginator)
+    rescue *SERVER_ERRORS => e
+      raise ServerError, e
+    end
+  end
+end

lib/bitbucket_server/collection.rb

+# frozen_string_literal: true
+
+module BitbucketServer
+  class Collection < Enumerator
+    def initialize(paginator)
+      super() do |yielder|
+        loop do
+          paginator.items.each { |item| yielder << item }
+        end
+      end
+
+      lazy
+    end
+
+    def method_missing(method, *args)
+      return super unless self.respond_to?(method)
+
+      self.__send__(method, *args) do |item| # rubocop:disable GitlabSecurity/PublicSend
+        block_given? ? yield(item) : item
+      end
+    end
+  end
+end

lib/bitbucket_server/connection.rb

+# frozen_string_literal: true
+
+module BitbucketServer
+  class Connection
+    include ActionView::Helpers::SanitizeHelper
+
+    DEFAULT_API_VERSION = '1.0'
+    SEPARATOR = '/'
+
+    attr_reader :api_version, :base_uri, :username, :token
+
+    ConnectionError = Class.new(StandardError)
+
+    def initialize(options = {})
+      @api_version = options.fetch(:api_version, DEFAULT_API_VERSION)
+      @base_uri = options[:base_uri]
+      @username = options[:user]
+      @token = options[:password]
+    end
+
+    def get(path, extra_query = {})
+      response = Gitlab::HTTP.get(build_url(path),
+                                  basic_auth: auth,
+                                  headers: accept_headers,
+                                  query: extra_query)
+
+      check_errors!(response)
+
+      response.parsed_response
+    end
+
+    def post(path, body)
+      response = Gitlab::HTTP.post(build_url(path),
+                                   basic_auth: auth,
+                                   headers: post_headers,
+                                   body: body)
+
+      check_errors!(response)
+
+      response.parsed_response
+    end
+
+    # We need to support two different APIs for deletion:
+    #
+    # /rest/api/1.0/projects/{projectKey}/repos/{repositorySlug}/branches/default
+    # /rest/branch-utils/1.0/projects/{projectKey}/repos/{repositorySlug}/branches
+    def delete(resource, path, body)
+      url = delete_url(resource, path)
+
+      response = Gitlab::HTTP.delete(url,
+                                     basic_auth: auth,
+                                     headers: post_headers,
+                                     body: body)
+
+      check_errors!(response)
+
+      response.parsed_response
+    end
+
+    private
+
+    def check_errors!(response)
+      raise ConnectionError, "Response is not valid JSON" unless response.parsed_response.is_a?(Hash)
+
+      return if response.code >= 200 && response.code < 300
+
+      details = sanitize(response.parsed_response.dig('errors', 0, 'message'))
+      message = "Error #{response.code}"
+      message += ": #{details}" if details
+
+      raise ConnectionError, message
+    rescue JSON::ParserError
+      raise ConnectionError, "Unable to parse the server response as JSON"
+    end
+
+    def auth
+      @auth ||= { username: username, password: token }
+    end
+
+    def accept_headers
+      @accept_headers ||= { 'Accept' => 'application/json' }
+    end
+
+    def post_headers
+      @post_headers ||= accept_headers.merge({ 'Content-Type' => 'application/json' })
+    end
+
+    def build_url(path)
+      return path if path.starts_with?(root_url)
+
+      url_join_paths(root_url, path)
+    end
+
+    def root_url
+      url_join_paths(base_uri, "/rest/api/#{api_version}")
+    end
+
+    def delete_url(resource, path)
+      if resource == :branches
+        url_join_paths(base_uri, "/rest/branch-utils/#{api_version}#{path}")
+      else
+        build_url(path)
+      end
+    end
+
+    # URI.join is stupid in that slashes are important:
+    #
+    # # URI.join('http://example.com/subpath', 'hello')
+    # => http://example.com/hello
+    #
+    # We really want http://example.com/subpath/hello
+    #
+    def url_join_paths(*paths)
+      paths.map { |path| strip_slashes(path) }.join(SEPARATOR)
+    end
+
+    def strip_slashes(path)
+      path = path[1..-1] if path.starts_with?(SEPARATOR)
+      path.chomp(SEPARATOR)
+    end
+  end
+end

lib/bitbucket_server/page.rb

+# frozen_string_literal: true
+
+module BitbucketServer
+  class Page
+    attr_reader :attrs, :items
+
+    def initialize(raw, type)
+      @attrs = parse_attrs(raw)
+      @items = parse_values(raw, representation_class(type))
+    end
+
+    def next?
+      !attrs.fetch(:isLastPage, true)
+    end
+
+    def next
+      attrs.fetch(:nextPageStart)
+    end
+
+    private
+
+    def parse_attrs(raw)
+      raw.slice('size', 'nextPageStart', 'isLastPage').symbolize_keys
+    end
+
+    def parse_values(raw, bitbucket_rep_class)
+      return [] unless raw['values'] && raw['values'].is_a?(Array)
+
+      bitbucket_rep_class.decorate(raw['values'])
+    end
+
+    def representation_class(type)
+      BitbucketServer::Representation.const_get(type.to_s.camelize)
+    end
+  end
+end

lib/bitbucket_server/paginator.rb

+# frozen_string_literal: true
+
+module BitbucketServer
+  class Paginator
+    PAGE_LENGTH = 25
+
+    def initialize(connection, url, type)
+      @connection = connection
+      @type = type
+      @url = url
+      @page = nil
+    end
+
+    def items
+      raise StopIteration unless has_next_page?
+
+      @page = fetch_next_page
+      @page.items
+    end
+
+    private
+
+    attr_reader :connection, :page, :url, :type
+
+    def has_next_page?
+      page.nil? || page.next?
+    end
+
+    def next_offset
+      page.nil? ? 0 : page.next
+    end
+
+    def fetch_next_page
+      parsed_response = connection.get(@url, start: next_offset, limit: PAGE_LENGTH)
+      Page.new(parsed_response, type)
+    end
+  end
+end

lib/bitbucket_server/representation/activity.rb

+# frozen_string_literal: true
+
+module BitbucketServer
+  module Representation
+    class Activity < Representation::Base
+      def comment?
+        action == 'COMMENTED'
+      end
+
+      def inline_comment?
+        !!(comment? && comment_anchor)
+      end
+
+      def comment
+        return unless comment?
+
+        @comment ||=
+          if inline_comment?
+            PullRequestComment.new(raw)
+          else
+            Comment.new(raw)
+          end
+      end
+
+      # TODO Move this into MergeEvent
+      def merge_event?
+        action == 'MERGED'
+      end
+
+      def committer_user
+        commit.dig('committer', 'displayName')
+      end
+
+      def committer_email
+        commit.dig('committer', 'emailAddress')
+      end
+
+      def merge_timestamp
+        timestamp = commit['committerTimestamp']
+
+        self.class.convert_timestamp(timestamp)
+      end
+
+      def merge_commit
+        commit['id']
+      end
+
+      def created_at
+        self.class.convert_timestamp(created_date)
+      end
+
+      private
+
+      def commit
+        raw.fetch('commit', {})
+      end
+
+      def action
+        raw['action']
+      end
+
+      def comment_anchor
+        raw['commentAnchor']
+      end
+
+      def created_date
+        raw['createdDate']
+      end
+    end
+  end
+end

lib/bitbucket_server/representation/base.rb

+# frozen_string_literal: true
+
+module BitbucketServer
+  module Representation
+    class Base
+      attr_reader :raw
+
+      def initialize(raw)
+        @raw = raw
+      end
+
+      def self.decorate(entries)
+        entries.map { |entry| new(entry)}
+      end
+
+      def self.convert_timestamp(time_usec)
+        Time.at(time_usec / 1000) if time_usec.is_a?(Integer)
+      end
+    end
+  end
+end

lib/bitbucket_server/representation/comment.rb

+# frozen_string_literal: true
+
+module BitbucketServer
+  module Representation
+    # A general comment with the structure:
+    # "comment": {
+    #   "author": {
+    #               "active": true,
+    #               "displayName": "root",
+    #               "emailAddress": "stanhu+bitbucket@gitlab.com",
+    #               "id": 1,
+    #               "links": {
+    #                 "self": [
+    #                   {
+    #                     "href": "http://localhost:7990/users/root"
+    #                   }
+    #                 ]
+    #                },
+    #                "name": "root",
+    #                "slug": "root",
+    #                "type": "NORMAL"
+    #               }
+    #   }
+    # }
+    class Comment < Representation::Base
+      attr_reader :parent_comment
+
+      CommentNode = Struct.new(:raw_comments, :parent)
+
+      def initialize(raw, parent_comment: nil)
+        super(raw)
+
+        @parent_comment = parent_comment
+      end
+
+      def id
+        raw_comment['id']
+      end
+
+      def author_username
+        author['displayName']
+      end
+
+      def author_email
+        author['emailAddress']
+      end
+
+      def note
+        raw_comment['text']
+      end
+
+      def created_at
+        self.class.convert_timestamp(created_date)
+      end
+
+      def updated_at
+        self.class.convert_timestamp(created_date)
+      end
+
+      # Bitbucket Server supports the ability to reply to any comment
+      # and created multiple threads. It represents these as a linked list
+      # of comments within comments. For example:
+      #
+      # "comments": [
+      #    {
+      #       "author" : ...
+      #       "comments": [
+      #          {
+      #             "author": ...
+      #
+      # Since GitLab only supports a single thread, we flatten all these
+      # comments into a single discussion.
+      def comments
+        @comments ||= flatten_comments
+      end
+
+      private
+
+      # In order to provide context for each reply, we need to track
+      # the parent of each comment. This method works as follows:
+      #
+      # 1. Insert the root comment into the workset. The root element is the current note.
+      # 2. For each node in the workset:
+      #    a. Examine if it has replies to that comment. If it does,
+      #       insert that node into the workset.
+      #    b. Parse that note into a Comment structure and add it to a flat list.
+      def flatten_comments
+        comments = raw_comment['comments']
+        workset =
+          if comments
+            [CommentNode.new(comments, self)]
+          else
+            []
+          end
+
+        all_comments = []
+
+        until workset.empty?
+          node = workset.pop
+          parent = node.parent
+
+          node.raw_comments.each do |comment|
+            new_comments = comment.delete('comments')
+            current_comment = Comment.new({ 'comment' => comment }, parent_comment: parent)
+            all_comments << current_comment
+            workset << CommentNode.new(new_comments, current_comment) if new_comments
+          end
+        end
+
+        all_comments
+      end
+
+      def raw_comment
+        raw.fetch('comment', {})
+      end
+
+      def author
+        raw_comment['author']
+      end
+
+      def created_date
+        raw_comment['createdDate']
+      end
+
+      def updated_date
+        raw_comment['updatedDate']
+      end
+    end
+  end
+end

lib/bitbucket_server/representation/pull_request.rb

+# frozen_string_literal: true
+
+module BitbucketServer
+  module Representation
+    class PullRequest < Representation::Base
+      def author
+        raw.dig('author', 'user', 'name')
+      end
+
+      def author_email
+        raw.dig('author', 'user', 'emailAddress')
+      end
+
+      def description
+        raw['description']
+      end
+
+      def iid
+        raw['id']
+      end
+
+      def state
+        case raw['state']
+        when 'MERGED'
+          'merged'
+        when 'DECLINED'
+          'closed'
+        else
+          'opened'
+        end
+      end
+
+      def merged?
+        state == 'merged'
+      end
+
+      def created_at
+        self.class.convert_timestamp(created_date)
+      end
+
+      def updated_at
+        self.class.convert_timestamp(updated_date)
+      end
+
+      def title
+        raw['title']
+      end
+
+      def source_branch_name
+        raw.dig('fromRef', 'id')
+      end
+
+      def source_branch_sha
+        raw.dig('fromRef', 'latestCommit')
+      end
+
+      def target_branch_name
+        raw.dig('toRef', 'id')
+      end
+
+      def target_branch_sha
+        raw.dig('toRef', 'latestCommit')
+      end
+
+      private
+
+      def created_date
+        raw['createdDate']
+      end
+
+      def updated_date
+        raw['updatedDate']
+      end
+    end
+  end
+end

lib/bitbucket_server/representation/pull_request_comment.rb

+# frozen_string_literal: true
+
+module BitbucketServer
+  module Representation
+    # An inline comment with the following structure that identifies
+    # the part of the diff:
+    #
+    # "commentAnchor": {
+    #   "diffType": "EFFECTIVE",
+    #   "fileType": "TO",
+    #   "fromHash": "c5f4288162e2e6218180779c7f6ac1735bb56eab",
+    #   "line": 1,
+    #   "lineType": "ADDED",
+    #   "orphaned": false,
+    #   "path": "CHANGELOG.md",
+    #   "toHash": "a4c2164330f2549f67c13f36a93884cf66e976be"
+    #  }
+    #
+    # More details in https://docs.atlassian.com/bitbucket-server/rest/5.12.0/bitbucket-rest.html.
+    class PullRequestComment < Comment
+      def from_sha
+        comment_anchor['fromHash']
+      end
+
+      def to_sha
+        comment_anchor['toHash']
+      end
+
+      def to?
+        file_type == 'TO'
+      end
+
+      def from?
+        file_type == 'FROM'
+      end
+
+      def added?
+        line_type == 'ADDED'
+      end
+
+      def removed?
+        line_type == 'REMOVED'
+      end
+
+      # There are three line comment types: added, removed, or context.
+      #
+      # 1. An added type means a new line was inserted, so there is no old position.
+      # 2. A removed type means a line was removed, so there is no new position.
+      # 3. A context type means the line was unmodified, so there is both a
+      #    old and new position.
+      def new_pos
+        return if removed?
+        return unless line_position
+
+        line_position[1]
+      end
+
+      def old_pos
+        return if added?
+        return unless line_position
+
+        line_position[0]
+      end
+
+      def file_path
+        comment_anchor.fetch('path')
+      end
+
+      private
+
+      def file_type
+        comment_anchor['fileType']
+      end
+
+      def line_type
+        comment_anchor['lineType']
+      end
+
+      # Each comment contains the following information about the diff:
+      #
+      # hunks: [
+      #     {
+      #         segments: [
+      #             {
+      #                 "lines": [
+      #                     {
+      #                         "commentIds": [ N ],
+      #                         "source": X,
+      #                         "destination": Y
+      #                     }, ...
+      #                   ] ....
+      #
+      # To determine the line position of a comment, we search all the lines
+      # entries until we find this comment ID.
+      def line_position
+        @line_position ||= diff_hunks.each do |hunk|
+          segments = hunk.fetch('segments', [])
+          segments.each do |segment|
+            lines = segment.fetch('lines', [])
+            lines.each do |line|
+              if line['commentIds']&.include?(id)
+                return [line['source'], line['destination']]
+              end
+            end
+          end
+        end
+      end
+
+      def comment_anchor
+        raw.fetch('commentAnchor', {})
+      end
+
+      def diff
+        raw.fetch('diff', {})
+      end
+
+      def diff_hunks
+        diff.fetch('hunks', [])
+      end
+    end
+  end
+end

lib/bitbucket_server/representation/repo.rb

+# frozen_string_literal: true
+
+module BitbucketServer
+  module Representation
+    class Repo < Representation::Base
+      def initialize(raw)
+        super(raw)
+      end
+
+      def project_key
+        raw.dig('project', 'key')
+      end
+
+      def project_name
+        raw.dig('project', 'name')
+      end
+
+      def slug
+        raw['slug']
+      end
+
+      def browse_url
+        # The JSON reponse contains an array of 1 element. Not sure if there
+        # are cases where multiple links would be provided.
+        raw.dig('links', 'self').first.fetch('href')
+      end
+
+      def clone_url
+        raw['links']['clone'].find { |link| link['name'].starts_with?('http') }.fetch('href')
+      end
+
+      def description
+        project['description']
+      end
+
+      def full_name
+        "#{project_name}/#{name}"
+      end
+
+      def issues_enabled?
+        true
+      end
+
+      def name
+        raw['name']
+      end
+
+      def valid?
+        raw['scmId'] == 'git'
+      end
+
+      def visibility_level
+        if project['public']
+          Gitlab::VisibilityLevel::PUBLIC
+        else
+          Gitlab::VisibilityLevel::PRIVATE
+        end
+      end
+
+      def project
+        raw['project']
+      end
+
+      def to_s
+        full_name
+      end
+    end
+  end
+end