Redmine › SCM Creator (+Github)

class RepositoryProtectedBranchesController < RedmineGitHostingController

  unloadable

  before_filter :set_current_tab

  before_filter :can_view_protected_branches,   :only => [:index]

  before_filter :can_create_protected_branches, :only => [:new, :create]

  before_filter :can_edit_protected_branches,   :only => [:edit, :update, :destroy]

  before_filter :find_repository_protected_branch, :except => [:index, :new, :create, :sort]

  def index

    @repository_protected_branches = RepositoryProtectedBranche.find_all_by_repository_id(@repository.id)

    respond_to do |format|

      format.html { render :layout => 'popup' }

      format.js

    end

  end

  def new

    @protected_branch = RepositoryProtectedBranche.new()

    @protected_branch.repository = @repository

    @protected_branch.user_list  = []

  end

  def create

    @protected_branch = RepositoryProtectedBranche.new(params[:repository_protected_branche])

    @protected_branch.repository = @repository

    respond_to do |format|

      if @protected_branch.save

        flash[:notice] = l(:notice_protected_branch_created)

        format.html { redirect_to success_url }

        format.js   { render :js => "window.location = #{success_url.to_json};" }

      else

        format.html {

          flash[:error] = l(:notice_protected_branch_create_failed)

          render :action => "create"

        }

        format.js { render "form_error", :layout => false }

      end

    end

  end

  def update

    respond_to do |format|

      if @protected_branch.update_attributes(params[:repository_protected_branche])

        flash[:notice] = l(:notice_protected_branch_updated)

        format.html { redirect_to success_url }

        format.js   { render :js => "window.location = #{success_url.to_json};" }

      else

        format.html {

          flash[:error] = l(:notice_protected_branch_update_failed)

          render :action => "edit"

        }

        format.js { render "form_error", :layout => false }

      end

    end

  end

  def destroy

    respond_to do |format|

      if @protected_branch.destroy

        flash[:notice] = l(:notice_protected_branch_deleted)

        format.js { render :js => "window.location = #{success_url.to_json};" }

      else

        format.js { render :layout => false }

      end

    end

  end

  def clone

    @protected_branch = RepositoryProtectedBranche.clone_from(params[:id])

    render "new"

  end

  def sort

    params[:repository_protected_branche].each_with_index do |id, index|

      RepositoryProtectedBranche.update_all({position: index + 1}, {id: id})

    end

    render :nothing => true

  end

  private

  def can_view_protected_branches

    render_403 unless view_context.user_allowed_to(:view_repository_protected_branches, @project)

  end

  def can_create_protected_branches

    render_403 unless view_context.user_allowed_to(:create_repository_protected_branches, @project)

  end

  def can_edit_protected_branches

    render_403 unless view_context.user_allowed_to(:edit_repository_protected_branches, @project)

  end

  def find_repository_protected_branch

    protected_branch = RepositoryProtectedBranche.find_by_id(params[:id])

    if protected_branch && protected_branch.repository_id == @repository.id

      @protected_branch = protected_branch

    elsif protected_branch

      render_403

    else

      render_404

    end

  end

  def set_current_tab

    @tab = 'repository_protected_branches'

  end

end

class RepositoryProtectedBranche < ActiveRecord::Base

  unloadable

  VALID_PERMS  = [ "RW+", "RW" ]

  DEFAULT_PERM = "RW+"

  acts_as_list

  ## Attributes

  attr_accessible :path, :permissions, :position, :user_list

  ## Relations

  belongs_to :repository

  ## Validations

  validates :repository_id, :presence => true

  validates :path,          :presence => true, :uniqueness => { :scope => :permissions }

  validates :permissions,   :presence => true, :inclusion => { :in => VALID_PERMS }

  validates :user_list,     :presence => true

  ## Serializations

  serialize :user_list, Array

  ## Callbacks

  before_validation :remove_blank_items

  after_commit ->(obj) { obj.update_permissions }, :on => :create

  after_commit ->(obj) { obj.update_permissions }, :on => :update

  after_commit ->(obj) { obj.update_permissions }, :on => :destroy

  ## Scopes

  default_scope order('position ASC')

  def self.clone_from(parent)

    parent = find_by_id(parent) unless parent.kind_of? RepositoryProtectedBranche

    copy = self.new

    copy.attributes = parent.attributes

    copy.repository = parent.repository

    copy

  end

  def available_users

    repository.project.member_principals.map(&:user).compact.uniq.map{ |user| user.login }.sort

  end

  def allowed_users

    self.user_list.map{ |user| User.find_by_login(user).gitolite_identifier }.sort

  end

  protected

  def update_permissions

    RedmineGitolite::GitHosting.logger.info { "Update branch permissions for repository : '#{repository.gitolite_repository_name}'" }

    RedmineGitolite::GitHosting.resync_gitolite(:update_repository, repository.id)

  end

  private

  def remove_blank_items

    self.user_list = user_list.select{ |user| !user.blank? } rescue []

  end

end

class DownloadGitRevision

  unloadable

  attr_reader :commit_valid

  attr_reader :content_type

  attr_reader :filename

  def initialize(repository, revision, format)

    @repository = repository

    @revision   = revision

    @format     = format

    @project    = repository.project

    @commit_valid  = false

    @commit_id     = ''

    @content_type  = ''

    @filename      = ''

    @cmd_args      = []

    validate_revision

    fill_data

  end

  def content

    RedmineGitolite::GitoliteWrapper.sudo_capture('git', "--git-dir=#{@repository.gitolite_repository_path}", 'archive', *@cmd_args, @commit_id)

  end

  private

  def validate_revision

    commit_id = nil

    # is the revision a branch?

    @repository.branches.each do |x|

      if x.to_s == @revision

        commit_id = x.revision

        break

      end

    end

    # is the revision a tag?

    if commit_id.nil?

      tags = RedmineGitolite::GitoliteWrapper.sudo_capture('git', "--git-dir=#{@repository.gitolite_repository_path}", 'tag').split

      tags.each do |x|

        if x == @revision

          commit_id = RedmineGitolite::GitoliteWrapper.sudo_capture('git', "--git-dir=#{@repository.gitolite_repository_path}", 'rev-list', @revision).split[0]

          break

        end

      end

    end

    # well, let check if this is a valid commit_id

    if commit_id.nil?

      commit_id = @revision

    end

    valid_commit = RedmineGitolite::GitoliteWrapper.sudo_capture('git', "--git-dir=#{@repository.gitolite_repository_path}", 'rev-parse', '--quiet', '--verify', commit_id).chomp.strip

    if valid_commit == ''

      @commit_valid = false

    else

      @commit_valid = true

      @commit_id = valid_commit

    end

  end

  def fill_data

    project_name = @project.to_s.parameterize.to_s

    if project_name.length == 0

      project_name = "tarball"

    end

    case @format

      when 'tar' then

        extension     = 'tar'

        @content_type = 'application/x-tar'

        @cmd_args << "--format=tar"

      when 'tar.gz' then

        extension     = 'tar.gz'

        @content_type = 'application/x-gzip'

        @cmd_args << "--format=tar.gz"

        @cmd_args << "-7"

      when 'zip' then

        extension     = 'zip'

        @content_type = 'application/x-zip'

        @cmd_args << "--format=zip"

        @cmd_args << "-7"

    end

    @filename = "#{project_name}-#{@revision}.#{extension}"

  end

end

class GitNotifier

  unloadable

  attr_reader :email_prefix

  attr_reader :sender_address

  attr_reader :default_list

  attr_reader :mail_mapping

  def initialize(repository)

    @repository     = repository

    @project        = repository.project

    @email_prefix   = ''

    @sender_address = ''

    @default_list   = []

    @mail_mapping   = {}

    build_notifier

  end

  def mailing_list

    @mail_mapping.keys

  end

  private

  def build_notifier

    set_email_prefix

    set_sender_address

    set_default_list

    set_mail_mapping

  end

  def set_email_prefix

    if !@repository.git_notification.nil? && !@repository.git_notification.prefix.empty?

      @email_prefix = @repository.git_notification.prefix

    else

      @email_prefix = RedmineGitolite::Config.get_setting(:gitolite_notify_global_prefix)

    end

  end

  def set_sender_address

    if !@repository.git_notification.nil? && !@repository.git_notification.sender_address.empty?

      @sender_address = @repository.git_notification.sender_address

    else

      @sender_address = RedmineGitolite::Config.get_setting(:gitolite_notify_global_sender_address)

    end

  end

  def set_default_list

    @default_list = @project.member_principals.map(&:user).compact.uniq

                                                          .select{|user| user.allowed_to?(:receive_git_notifications, @project)}

                                                          .map(&:mail).uniq.sort

  end

  def set_mail_mapping

    mail_mapping = {}

    # First collect all project users

    default_users = @default_list.map{ |mail| mail_mapping[mail] = :project }

    # Then add global include list

    RedmineGitolite::Config.get_setting(:gitolite_notify_global_include).sort.map{ |mail| mail_mapping[mail] = :global }

    # Then filter

    mail_mapping = filter_list(mail_mapping)

    # Then add local include list

    if !@repository.git_notification.nil? && !@repository.git_notification.include_list.empty?

      @repository.git_notification.include_list.sort.map{ |mail| mail_mapping[mail] = :local }

    end

    @mail_mapping = mail_mapping

  end

  def filter_list(merged_map)

    mail_mapping = {}

    exclude_list = []

    # Build exclusion list

    if !RedmineGitolite::Config.get_setting(:gitolite_notify_global_exclude).empty?

      exclude_list = RedmineGitolite::Config.get_setting(:gitolite_notify_global_exclude)

    end

    if !@repository.git_notification.nil? && !@repository.git_notification.exclude_list.empty?

      exclude_list = exclude_list + @repository.git_notification.exclude_list

    end

    exclude_list = exclude_list.uniq.sort

    merged_map.each do |mail, from|

      mail_mapping[mail] = from unless exclude_list.include?(mail)

    end

    return mail_mapping

  end

end

class GithubPayload

  unloadable

  attr_reader :payload

  def initialize(repository, payload)

    @repository = repository

    @project    = repository.project

    @payload    = build_payload(payload)

  end

  private

  def logger

    RedmineGitolite::Log.get_logger(:git_hooks)

  end

  # Returns an array of GitHub post-receive hook style hashes

  # http://help.github.com/post-receive-hooks/

  def build_payload(refs)

    payload = []

    refs.each do |ref|

      oldhead, newhead, refname = ref.split(',')

      # Only pay attention to branch updates

      next if !refname.match(/refs\/heads\//)

      branch = refname.gsub('refs/heads/', '')

      if newhead.match(/^0{40}$/)

        # Deleting a branch

        logger.info { "Deleting branch '#{branch}'" }

        next

      elsif oldhead.match(/^0{40}$/)

        # Creating a branch

        logger.info { "Creating branch '#{branch}'" }

        range = newhead

      else

        range = "#{oldhead}..#{newhead}"

      end

      # Grab the repository path

      revisions_in_range = RedmineGitolite::GitoliteWrapper.sudo_capture('git', "--git-dir=#{@repository.gitolite_repository_path}", 'rev-list', '--reverse', range)

      logger.debug { "Revisions in range : #{revisions_in_range.split().join(' ')}" }

      commits = []

      revisions_in_range.split().each do |rev|

        logger.debug { "Revision : '#{rev.strip}'" }

        revision = @repository.find_changeset_by_name(rev.strip)

        next if revision.nil?

        revision_url = Rails.application.routes.url_helpers.url_for(

                         :controller => 'repositories', :action => 'revision',

                         :id => @project, :repository_id => @repository.identifier_param, :rev => rev,

                         :only_path => false, :host => Setting['host_name'], :protocol => Setting['protocol']

                       )

        commit = {

          :id        => revision.revision,

          :message   => revision.comments,

          :timestamp => revision.committed_on,

          :added     => [],

          :modified  => [],

          :removed   => [],

          :url       => revision_url,

          :author    => {

            :name  => revision.committer.gsub(/^([^<]+)\s+.*$/, '\1'),

            :email => revision.committer.gsub(/^.*<([^>]+)>.*$/, '\1')

          }

        }

        revision.filechanges.each do |change|

          if change.action == "M"

            commit[:modified] << change.path

          elsif change.action == "A"

            commit[:added] << change.path

          elsif change.action == "D"

            commit[:removed] << change.path

          end

        end

        commits << commit

      end

      repository_url = Rails.application.routes.url_helpers.url_for(

                         :controller => 'repositories', :action => 'show',

                         :id => @project, :repository_id => @repository.identifier_param,

                         :only_path => false, :host => Setting['host_name'], :protocol => Setting['protocol']

                       )

      payload << {

        :before     => oldhead,

        :after      => newhead,

        :ref        => refname,

        :commits    => commits,

        :pusher     => {

          :name  => Setting["app_title"],

          :email => Setting["mail_from"]

        },

        :repository => {

          :description => @project.description,

          :fork        => false,

          :forks       => 0,

          :homepage    => @project.homepage,

          :name        => @repository.redmine_name,

          :open_issues => @project.issues.open.length,

          :watchers    => 0,

          :private     => !@project.is_public,

          :url         => repository_url,

          :owner       => {

            :name  => Setting["app_title"],

            :email => Setting["mail_from"]

          }

        }

      }

    end

    return payload

  end

end

module Hooks

  class GitMirrors

    unloadable

    def initialize(repository, payload)

      @repository = repository

      @project    = repository.project

      @payload    = payload

    end

    def execute

      call_mirrors

    end

    private

    def logger

      RedmineGitolite::Log.get_logger(:git_hooks)

    end

    def call_mirrors

      y = ""

      ## Push to each mirror

      if @repository.mirrors.active.any?

        logger.info { "Notifying mirrors about changes to this repository :" }

        y << "\nNotifying mirrors about changes to this repository :\n"

        @repository.mirrors.active.each do |mirror|

          if mirror.needs_push(@payload)

            logger.info { "Pushing changes to #{mirror.url} ... " }

            y << "  - Pushing changes to #{mirror.url} ... "

            push_failed, push_message = mirror.push

            if push_failed

              logger.error { "Failed!" }

              logger.error { "#{push_message}" }

              y << " [failure]\n"

            else

              logger.info { "Succeeded!" }

              y << " [success]\n"

            end

          end

        end

      end

      return y

    end

  end

end

require 'json'

module Hooks

  class GithubIssuesSync

    unloadable

    include HttpHelper

    def initialize(project, params)

      @project = project

      @params  = params

    end

    def execute

      sync_with_github

    end

    private

    def logger

      RedmineGitolite::Log.get_logger(:git_hooks)

    end

    def sync_with_github

      github_issue = GithubIssue.find_by_github_id(@params[:issue][:id])

      redmine_issue = Issue.find_by_subject(@params[:issue][:title])

      create_relation = false

      ## We don't have stored relation

      if github_issue.nil?

        ## And we don't have issue in Redmine

        if redmine_issue.nil?

          create_relation = true

          redmine_issue = create_redmine_issue

        else

          ## Create relation and update issue

          create_relation = true

          redmine_issue = update_redmine_issue(redmine_issue)

        end

      else

        ## We have one relation, update issue

        redmine_issue = update_redmine_issue(github_issue.issue)

      end

      if create_relation

        github_issue = GithubIssue.new

        github_issue.github_id = @params[:issue][:id]

        github_issue.issue_id = redmine_issue.id

        github_issue.save!

      end

      if @params.has_key?(:comment)

        issue_journal = GithubComment.find_by_github_id(@params[:comment][:id])

        if issue_journal.nil?

          issue_journal = create_issue_journal(github_issue.issue)

          github_comment = GithubComment.new

          github_comment.github_id = @params[:comment][:id]

          github_comment.journal_id = issue_journal.id

          github_comment.save!

        end

      end

    end

    def create_redmine_issue

      logger.info { "Github Issues Sync : create new issue" }

      issue = Issue.new

      issue.project_id = @project.id

      issue.tracker_id = @project.trackers.find(:first).try(:id)

      issue.subject = @params[:issue][:title].chomp[0, 255]

      issue.description = @params[:issue][:body]

      issue.updated_on = @params[:issue][:updated_at]

      issue.created_on = @params[:issue][:created_at]

      ## Get user mail

      user = find_user(@params[:issue][:user][:url])

      issue.author = user

      issue.save!

      return issue

    end

    def create_issue_journal(issue)

      logger.info { "Github Issues Sync : create new journal for issue '##{issue.id}'" }

      journal = Journal.new

      journal.journalized_id = issue.id

      journal.journalized_type = 'Issue'

      journal.notes = @params[:comment][:body]

      journal.created_on = @params[:comment][:created_at]

      ## Get user mail

      user = find_user(@params[:comment][:user][:url])

      journal.user_id = user.id

      journal.save!

      return journal

    end

    def update_redmine_issue(issue)

      logger.info { "Github Issues Sync : update issue '##{issue.id}'" }

      if @params[:issue][:state] == 'closed'

        issue.status_id = 5

      else

        issue.status_id = 1

      end

      issue.subject = @params[:issue][:title].chomp[0, 255]

      issue.description = @params[:issue][:body]

      issue.updated_on = @params[:issue][:updated_at]

      issue.save!

      return issue

    end

    def find_user(url)

      post_failed, user_data = post_data(url, "", :method => :get)

      user_data = JSON.parse(user_data)

      user = User.find_by_mail(user_data['email'])

      if user.nil?

        logger.info { "Github Issues Sync : cannot find user '#{user_data['email']}' in Redmine, use anonymous" }

        user = User.anonymous

        user.mail = user_data['email']

        user.firstname = user_data['name']

        user.lastname  = user_data['login']

      end

      return user

    end

  end

end

require 'net/http'

require 'net/https'

require 'uri'

module Hooks

  module HttpHelper

    unloadable

    def post_data(url, payload, opts={})

      uri  = URI(url)

      http = Net::HTTP.new(uri.host, uri.port)

      if uri.scheme == 'https'

        http.use_ssl = true

        http.verify_mode = OpenSSL::SSL::VERIFY_NONE

      end

      if opts[:method] == :post

        request = Net::HTTP::Post.new(uri.request_uri)

        request.set_form_data({"payload" => payload.to_json})

      else

        request = Net::HTTP::Get.new(uri.request_uri)

      end

      message = ""

      begin

        res = http.start {|openhttp| openhttp.request request}

        if !res.is_a?(Net::HTTPSuccess)

          message = "Return code : #{res.code} (#{res.message})."

          failed = true

        else

          message = res.body

          failed = false

        end

      rescue => e

        message = "Exception : #{e.message}"

        failed = true

      end

      return failed, message

    end

  end

end

module Hooks

  class Redmine

    unloadable

    def initialize(repository)

      @repository = repository

    end

    def execute

      fetch_changesets

    end

    private

    def logger

      RedmineGitolite::Log.get_logger(:git_hooks)

    end

    def fetch_changesets

      ## Fetch commits from the repository

      y = ""

      logger.info { "Fetching changesets for '#{@repository.redmine_name}' repository ... " }

      y << "  - Fetching changesets for '#{@repository.redmine_name}' repository ... "

      begin

        @repository.fetch_changesets

        logger.info { "Succeeded!" }

        y << " [success]\n"

      rescue ::Redmine::Scm::Adapters::CommandFailed => e

        logger.error { "Failed!" }

        logger.error { "Error during fetching changesets : #{e.message}" }

        y << " [failure]\n"

      rescue => e

        logger.error { "Failed!" }

        logger.error { "Error after fetching changesets : #{e.message}" }

        y << " [failure]\n"

      end

      return y

    end

  end

end

module Hooks

  class Webservices

    unloadable

    include HttpHelper

    def initialize(repository, payload)

      @repository = repository

      @project    = repository.project

      @payload    = payload

    end

    def execute

      call_webservices

    end

    private

    def logger

      RedmineGitolite::Log.get_logger(:git_hooks)

    end

    def call_webservices

      y = ""

      ## Post to each post-receive URL

      if @repository.post_receive_urls.active.any?

        logger.info { "Notifying post receive urls about changes to this repository :" }

        y << "\nNotifying post receive urls about changes to this repository :\n"

        @repository.post_receive_urls.active.each do |post_receive_url|

          if payloads = post_receive_url.needs_push(@payload)

            method = (post_receive_url.mode == :github) ? :post : :get

            if method == :post && post_receive_url.split_payloads?

              payloads.each do |payload|

                logger.info { "Notifying #{post_receive_url.url} for '#{payload[:ref]}' ... " }

                y << "  - Notifying #{post_receive_url.url} for '#{payload[:ref]}' ... "

                post_failed, post_message = post_data(post_receive_url.url, payload, :method => method)

                if post_failed

                  logger.error { "Failed!" }

                  logger.error { "#{post_message}" }

                  y << " [failure]\n"

                else

                  logger.info { "Succeeded!" }

                  y << " [success]\n"

                end

              end

            else

              logger.info { "Notifying #{post_receive_url.url} ... " }

              y << "  - Notifying #{post_receive_url.url} ... "

              post_failed, post_message = post_data(post_receive_url.url, @payload, :method => method)

              if post_failed

                logger.error { "Failed!" }

                logger.error { "#{post_message}" }

                y << " [failure]\n"

              else

                logger.info { "Succeeded!" }

                y << " [success]\n"

              end

            end

          end

        end

      end

      return y

    end

  end

end

<div id="validation_messages"><%= error_messages_for 'gitolite_public_key' %></div>

<%= labelled_form_for :gitolite_public_key, gitolite_public_key,

                      :url  => {:controller => 'gitolite_public_keys', :action => 'create', :user_id => params[:id], :tab => params[:id]&&'keys'},

                      :html => {:method => :post} do |f| %>

  <p><%= f.text_field :title, :label => :label_identifier_can_be_arbitrary, :required => true, :style => 'width: 97%;' %></p>

  <% if can_create_deployment_keys_for_some_project(@user) %>

    <p>

      <%= f.select :key_type, options_for_select(

                                [

                                  [ l(:label_user_key), 0 ],

                                  [ l(:label_deploy_key), 1 ]

                                ],

                              ),

                              { :required => true, :label => :label_key_type },

                              { :class    => 'select_key_type' } %>

    </p>

    <div id="key_type_options" style="display: none;">

      <p>

        <%= f.check_box :delete_when_unused, :required => true, :label => :label_deployment_credential_delete_when_unused %>

      </p>

    </div>

  <% end %>

  <p>

    <%= f.text_area :key, :label => :label_public_key, :required => true,

          :style => "width: 97%; height: 200px; overflow: auto;",

          :cols => nil,

          :rows => nil %>

  </p>

  <em><%= l(:label_cut_and_paste) %></em><br /><br />

  <%= submit_tag l(:button_create), :name => 'create_button' %>

  <%= submit_tag l(:button_cancel), :name => 'cancel_button' %>

<% end %>

<%= render :partial => 'gitolite_public_keys/view' %>

<% if @repository.is_a?(Repository::Git) %>

  <div id="repository-tabs">

    <ul>

      <% if user_allowed_to(:view_deployment_keys, @repository.project) %>

        <li id="tab-repository_deployment_credentials">

          <%= link_to label_with_icon(l(:label_deployment_credentials), 'fa-ticket'),

                      repository_deployment_credentials_path(@repository) %>

        </li>

      <% end %>

      <% if user_allowed_to(:view_repository_git_notifications, @repository.project) %>

        <li id="tab-repository_git_notifications">

          <%= link_to label_with_icon(l(:label_git_notifications), 'fa-envelope'),

                      repository_git_notifications_path(@repository) %>

        </li>

      <% end %>

      <% if user_allowed_to(:view_repository_mirrors, @repository.project) %>

        <li id="tab-repository_mirrors">

          <%= link_to label_with_icon(l(:label_repository_mirrors), 'fa-sitemap'),

                      repository_mirrors_path(@repository) %>

        </li>

      <% end %>

      <% if user_allowed_to(:view_repository_post_receive_urls, @repository.project) %>

        <li id="tab-repository_post_receive_urls">

          <%= link_to label_with_icon(l(:label_post_receive_urls), 'fa-external-link'),

                      repository_post_receive_urls_path(@repository) %>

        </li>

      <% end %>

      <% if user_allowed_to(:view_repository_git_config_keys, @repository.project) %>

        <li id="tab-repository_git_config_keys">

          <%= link_to label_with_icon(l(:label_git_config_keys), 'fa-th-list'),

                      repository_git_config_keys_path(@repository) %>

        </li>

      <% end %>

      <% if user_allowed_to(:view_repository_protected_branches, @repository.project) %>

        <li id="tab-repository_protected_branches">

          <%= link_to "<i class=\"fa fa-lock\"></i>".html_safe + l(:label_protected_branches),

                      repository_protected_branches_path(@repository) %>

        </li>

      <% end %>

    </ul>

  </div>

  <div id="modal-box"></div>

  <div id="modal-box-close-only"></div>

  <% content_for :header_tags do %>

    <%= stylesheet_link_tag 'font_awesome',                     :plugin => 'redmine_bootstrap_kit' %>

    <%= stylesheet_link_tag 'jquery_tag_it',                    :plugin => 'redmine_bootstrap_kit' %>

    <%= stylesheet_link_tag 'bootstrap/bootstrap_custom',       :plugin => 'redmine_bootstrap_kit' %>

    <%= stylesheet_link_tag 'bootstrap/bootstrap_label',        :plugin => 'redmine_bootstrap_kit' %>

    <%= stylesheet_link_tag 'bootstrap/bootstrap_tables',       :plugin => 'redmine_bootstrap_kit' %>

    <%= javascript_include_tag 'jquery_tag_it',                 :plugin => 'redmine_bootstrap_kit' %>

    <%= javascript_include_tag 'bootstrap',                     :plugin => 'redmine_bootstrap_kit' %>

    <%= javascript_tag do %>

      function post_mode_change(elem) {

        if (!elem) return;

        var idx = elem.selectedIndex;

        if (idx == 0) {

          $('#payload_options').show();

        } else {

          $('#payload_options').hide();

        }

      }

      function push_mode_change(elem) {

        if (!elem) return;

        var idx = elem.selectedIndex;

        if (idx == 0) {

          $('#ref_spec_options').hide();

        } else {

          $('#ref_spec_options').show();

        }

      }

      function key_mode_change(elem) {

        if (!elem) return;

        var idx = elem.selectedIndex;

        if (idx == 0) {

          $('#new_key_window').show();

        } else {

          $('#new_key_window').hide();

        }

      }

      var modals           = Object();

      modals.label_save    = '<%= l(:button_save) %>';

      modals.label_cancel  = '<%= l(:button_cancel) %>';

      modals.label_ok      = '<%= l(:button_ok) %>';

      modals.modal_list    = [];

      modals.modal_list[0] = {'source': '.modal-box', 'target': '#modal-box', 'mode': 'standard'};

      modals.modal_list[1] = {'source': '.modal-box-close-only', 'target': '#modal-box-close-only', 'mode': 'close-only'};

      $(document).ready(function() {

        var all_tabs = $("#repository-tabs li");

        var active_tab = '';

        all_tabs.each(function(){

          if ($(this).attr('id').replace('tab-', '') == '<%= @tab %>') {

            active_tab = all_tabs.index(this);

          }

        });

        $("#repository-tabs").tabs({

          active: active_tab,

          activate: function(event, ui) {

            var new_tab_name = $(ui.newTab).attr('id').replace('tab-', '');

            if ("replaceState" in window.history) {

              window.history.replaceState(null, document.title, 'edit?tab=' + new_tab_name);

            }

          }

        });

      });

    <% end %>

  <% end %>

<% end %>

<% if @repository.is_a?(Repository::Git) %>

  <div class="git_hosting box">

    <h3><%= l(:label_repository_access_url) %></h3>

    <%= render :partial => 'common/git_urls', :locals => {:repository => @repository} %>

  </div>

<% end %>

<% content_for :header_tags do %>

  <%= stylesheet_link_tag    'bootstrap/bootstrap_switch', :plugin => 'redmine_bootstrap_kit' %>

  <%= javascript_include_tag 'plugins/bootstrap_switch',   :plugin => 'redmine_bootstrap_kit' %>

  <%= javascript_include_tag 'bootstrap',                  :plugin => 'redmine_bootstrap_kit' %>

<% end %>

<%= javascript_tag do %>

  $(document).ready(function() {

    // Actually this takes the parent <p> mark

    var default_checkbox = $('#repository_is_default').parent();

    <% if @project.repository.nil? %>

      // The default repository is not set, nothing to do...

    <% elsif @project.repository == @repository %>

      var content = $('<%= content_tag :p do -%>

        <%= hidden_field_tag "repository[is_default]", "1" -%>

        <%= content_tag :label, l(:field_repository_is_default) -%>

        <%= content_tag :span,  l(:label_yes), :class => 'label label-success' -%>

      <% end -%>');

      content.insertAfter(default_checkbox);

      default_checkbox.remove();

      $('#repository_identifier').parent().remove();

    <% else %>

      var content = $('<%= content_tag :p do -%>

        <%= hidden_field_tag "repository[is_default]", "0" -%>

        <%= content_tag :label, l(:field_repository_is_default) -%>

        <%= content_tag :span,  l(:label_no), :class => 'label' -%>

      <% end -%>');

      content.insertAfter(default_checkbox);

      default_checkbox.remove();

    <% end %>

  });

<% end %>

<% if @repository.is_a?(Repository::Git) %>

  <%= javascript_tag do %>

    function moveGitOptionsDiv(){

      if ( $('#git_hosting_settings').length == 0 ) {

        // Set selectors

        var original_div = $('#repository_git_options').parent();

        var new_div      = $('#repository_git_options');

        // Wrap the original_div in a new div

        original_div.wrap('<div id="git_hosting_settings" class="box tabular">');

        // Remove original css class

        original_div.removeClass('box tabular');

        // Add new css class

        original_div.addClass('split');

        // Insert our div after the original one

        new_div.insertAfter(original_div);

        $('<div style="display: block; clear: both;"></div>').insertAfter(new_div);

        new_div.show();

      }

    }

    $(document).ready(function() {

      $('#repository_url').parent().remove();

      moveGitOptionsDiv();

      $('.bootstrap-switch').each(function(index, element) {

        if (!$(element).children('div').length > 0){

          installBootstrapSwitch(element);

        }

      });

    });

  <% end %>

  <div id="repository_git_options" class="split" style="display: none;">

    <h3><%= l(:label_repository_options) %></h3>

    <%

      selected = "false"

      if @repository.extra[:git_daemon]

        selected = "true"

      elsif @project.is_public && RedmineGitolite::Config.get_setting(:gitolite_daemon_by_default, true)

        selected = "true"

      end

    %>

    <p>

      <label><%= l(:label_enable_git_daemon) %></label>

      <span class="bootstrap-switch switch-small" data-on="primary" data-off="default" data-on-label="<%= l(:label_yes) %>" data-off-label="<%= l(:label_no) %>">

        <%= hidden_field_tag "extra[git_daemon]", "false" %>

        <%= check_box_tag "extra[git_daemon]", selected, (selected == "true" ? true : false), disabled: !@project.is_public %>

      </span>

    </p>

    <% if user_allowed_to(:create_repository_git_notifications, @repository.project) %>

      <p>

        <label><%= l(:label_enable_git_notify) %></label>

        <span class="bootstrap-switch switch-small" data-on="primary" data-off="default" data-on-label="<%= l(:label_yes) %>" data-off-label="<%= l(:label_no) %>">

          <%= hidden_field_tag "extra[git_notify]", "false" %>

          <%= check_box_tag "extra[git_notify]", @repository.extra[:git_notify], @repository.extra[:git_notify] %>

        </span>

      </p>

    <% end %>

    <% if user_allowed_to(:create_repository_protected_branches, @repository.project) %>

      <p>

        <label><%= l(:label_enable_protected_branches) %></label>

        <span class="bootstrap-switch switch-small" data-on="primary" data-off="default" data-on-label="<%= l(:label_yes) %>" data-off-label="<%= l(:label_no) %>">

          <%= hidden_field_tag "extra[protected_branch]", "false" %>

          <%= check_box_tag "extra[protected_branch]", @repository.extra[:protected_branch], @repository.extra[:protected_branch] %>

        </span>

      </p>

    <% end %>

    <p>

      <%= label_tag  "extra[git_http]", l(:label_enable_smart_http) %>

      <%= select_tag "extra[git_http]", options_for_select([

                                                              [l(:label_disabled), "0"],

                                                              [l(:label_http_only), "3"],

                                                              [l(:label_https_only), "1"],

                                                              [l(:label_https_and_http), "2"]

                                                            ], :selected => @repository.extra[:git_http].to_s) %>

    </p>

    <p>

      <%= label_tag  "", l(:label_repository_default_branch) %>

      <% if !@repository.new_record? && !@repository.branches.empty? %>

        <%= select_tag "extra[default_branch]", options_for_select(@repository.branches.collect{ |b| [b.to_s, b.to_s] }, :selected => @repository.branches.find{ |b| b.is_default}.to_s) %>

      <% else %>

        <span class="label label-info"><%= @repository.extra[:default_branch] %></span>

      <% end %>

    </p>

    <p>

      <%= label_tag  "", l(:label_mirroring_keys_installed) %>

      <%= image_tag (RedmineGitolite::GitoliteWrapper.mirroring_keys_installed? ? 'true.png' : 'exclamation.png') %>

    </p>

    <% if !@repository.new_record? %>

      <p>

        <%= label_tag  "", l(:label_repository_exists_in_gitolite) %>

        <%= image_tag (@repository.exists_in_gitolite? ? 'true.png' : 'exclamation.png') %>

      </p>

      <p>

        <label><%= l(:label_browse_repository) %></label>

        <%= link_to h(@repository.url), {:controller => 'repositories', :action => 'show', :id => @project, :repository_id => @repository.identifier_param} %>

      </p>

    <% else %>

      <%= javascript_tag do %>

        $(document).ready(function() {

          var content = $('<%= content_tag :p do -%>

            <%= hidden_field_tag "repository[create_readme]", "false" -%>

            <%= content_tag :label, l(:label_init_repo_with_readme) -%>

            <%= check_box_tag "repository[create_readme]", "true", RedmineGitolite::Config.get_setting(:init_repositories_on_create, true) -%>

          <% end -%>');

          if ($('#repository_create_readme').length == 0) {

            content.insertAfter($('#repository_identifier').parent());

          }

        });

      <% end %>

    <% end %>

  </div>

<% end %>

<%= javascript_tag do %>

  $(document).ready(function() {

    $('#sidebar p').remove();

  });

<% end %>

<ul class="repository git">

  <% @repositories.sort.each do |repo| %>

      <li class="repository git"><%= link_to h(repo.name), {:controller => 'repositories', :action => 'show', :id => @project, :repository_id => repo.identifier_param, :rev => nil, :path => nil},

                                    :class => [ 'repository', (repo == @repository ? 'selected' : ''), @repository.type.split('::')[1].downcase ].join(' ') %>

      </li>

  <% end %>

</ul>

<% if @repository.is_a?(Repository::Git) && RedmineGitolite::Config.get_setting(:show_repositories_url, true) %>

  <div class="git_hosting_urls">

    <h3><%= l(:label_repository_access_url) %></h3>

    <%= render :partial => 'common/git_urls', :locals => {:repository => @repository} %>

  </div>

<% end %>

<%= render :partial => 'repositories/download_revision' %>

<div id="validation_messages_protected_branch"><%= error_messages_for 'protected_branch' %></div>

<div class="box">

  <p><%= f.text_field :path,        :required => true, :size => 65, :label => l(:label_branch_path) %></p>

  <p><%= f.select     :permissions, options_for_select(RepositoryProtectedBranche::VALID_PERMS, @protected_branch.permissions),

                      :required => true,

                      :label    => :label_permissions %>

  </p>

  <%= hidden_field_tag "repository_protected_branche[user_list][]", "" %>

  <p><label for="repository_protected_branche[user_list]"><%= l(:label_user_list) %> :</label></p>

  <ul id="user_list">

    <% if @protected_branch.user_list.any? %>

      <% @protected_branch.user_list.each do |item| %>

        <li><%= item %></li>

      <% end %>

    <% end %>

  </ul>

</div>

<%= javascript_tag do %>

  var user_list = <%= raw @protected_branch.available_users.to_json %>;

  function loadTagIt(target){

    $('#' + target).gtagit({

      autocomplete: {source: function(request, resolve) {

          // fetch new values with request.resolve

          resolve(user_list);

        }

      },

      afterTagAdded: function(event, ui) {

        var value = ui.tag.children('input:hidden').val();

        user_list = user_list.filter(function(v) { return v != value;});

        $(".ui-dialog-content").dialog("option", "position", ['center', 'center']).animate('slow');

      },

      afterTagRemoved: function(event, ui) {

        var value = ui.tag.children('input:hidden').val();

        user_list.push(value);

        $(".ui-dialog-content").dialog("option", "position", ['center', 'center']).animate('slow');

      },

      showAutocompleteOnFocus: true,

      placeholderText: '+ add user',

      allowDuplicates: false,

      caseSensitive: false,

      fieldName: 'repository_protected_branche[' + target + '][]',

    });

  }

  $(document).ready(function() {

    loadTagIt('user_list');

  });

<% end %>

<% if !@is_xhr %>

  <h2><%= l(:label_protected_branch_edit) %></h2>

<% end %>

<%= labelled_form_for :repository_protected_branche, @protected_branch,

                      :url  => repository_protected_branch_path(@repository, @protected_branch),

                      :html => { :method => :put, :class => 'tabular', :remote => @is_xhr } do |f| %>

  <%= render :partial => 'form', :locals => { :f => f } %>

  <% if !@is_xhr %>

    <%= submit_tag l(:button_save), :disable_with => l(:label_backup_in_progress) %>

    <%= link_to l(:button_cancel), url_for(:controller => 'repositories', :action => 'edit', :id => @repository.id) %>

  <% end %>

<% end %>

$('#validation_messages_protected_branch').html("<%= escape_javascript(error_messages_for 'protected_branch') %>");

<div>

  <% if user_allowed_to(:create_repository_protected_branches, @project) %>

    <div class="contextual">

      <%= link_to(l(:label_protected_branch_add), new_repository_protected_branch_path(@repository),

                                                  :class => 'icon icon-add modal-box') %>

    </div>

  <% end %>

  <h3><%= l(:label_protected_branches) %></h3>

  <% if @repository_protected_branches.any? %>

    <table id="protected_branches" class="table table-hover" data-update-url="<%= sort_repository_protected_branches_url %>">

      <thead>