Redmine

  def committers

    @committers = @repository.committers

    @users = @project.users

    additional_user_ids = @committers.collect(&:last).collect(&:to_i) - @users.collect(&:id)

    @users += User.find_all_by_id(additional_user_ids) unless additional_user_ids.empty?

    @users.compact!

    @users.sort!

    if request.post?

      @repository.committer_ids = params[:committers]

      flash[:notice] = l(:notice_successful_update)

      redirect_to :action => 'committers', :id => @project

    end

  end

# Redmine - project management software

# Copyright (C) 2006-2008  Jean-Philippe Lang

  belongs_to :user

  def author

    user || committer.to_s.split('<').first

  end

  def before_create

    self.user = repository.find_committer_user(committer)

  end

          journal = issue.init_journal(user || User.anonymous, l(:text_status_changed_by_changeset, csettext))

  # Returns an array of committers usernames and associated user_id

  def committers

    @committers ||= Changeset.connection.select_rows("SELECT DISTINCT committer, user_id FROM #{Changeset.table_name} WHERE repository_id = #{id}")

  end

  # Maps committers username to a user ids

  def committer_ids=(h)

    if h.is_a?(Hash)

      committers.each do |committer, user_id|

        new_user_id = h[committer]

        if new_user_id && (new_user_id.to_i != user_id.to_i)

          new_user_id = (new_user_id.to_i > 0 ? new_user_id.to_i : nil)

          Changeset.update_all("user_id = #{ new_user_id.nil? ? 'NULL' : new_user_id }", ["repository_id = ? AND committer = ?", id, committer])

        end

      end

      @committers = nil

      true

    else

      false

    end

  end

  # Returns the Redmine User corresponding to the given +committer+

  # It will return nil if the committer is not yet mapped and if no User

  # with the same username or email was found

  def find_committer_user(committer)

    if committer

      c = changesets.find(:first, :conditions => {:committer => committer}, :include => :user)

      if c && c.user

        c.user

      elsif committer.strip =~ /^([^<]+)(<(.*)>)?$/

        username, email = $1.strip, $3

        u = User.find_by_login(username)

        u ||= User.find_by_mail(email) unless email.blank?

        u

      end

    end

  end

  has_many :changesets, :dependent => :nullify

        <span class="author"><%= authoring(changeset.committed_on, changeset.author) %></span></p>

		    pdf.Cell(190,5, format_time(changeset.committed_on) + " - " + changeset.author)

<% if @repository && [email protected]_record? %>

<%= link_to(l(:label_user_plural), {:controller => 'repositories', :action => 'committers', :id => @project}, :class => 'icon icon-user') %>

            :class => 'icon icon-del') %>

<% end %>

<% changeset = @project.repository.changesets.find_by_revision(entry.lastrev.identifier) if entry.lastrev && entry.lastrev.identifier %>

<td class="author"><%= changeset.nil? ? h(entry.lastrev.author.to_s.split('<').first) : changeset.author if entry.lastrev %></td>

<td class="author"><%=h changeset.author %></td>

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

<%= simple_format(l(:text_repository_usernames_mapping)) %>

<% if @committers.empty? %>

<p class="nodata"><%= l(:label_no_data) %></p>

<% else %>

<% form_tag({}) do %>

<table class="list">

<thead>

	<tr>

		<th><%= l(:field_login) %></th>

		<th><%= l(:label_user) %></th>

	</tr>

</thead>

<tbody>

<% @committers.each do |committer, user_id| -%>

	<tr class="<%= cycle 'odd', 'even' %>">

		<td><%=h committer %></td>

		<td><%= select_tag "committers[#{committer}]", content_tag('option', "-- #{l :actionview_instancetag_blank_option} --", :value => '') + options_from_collection_for_select(@users, 'id', 'name', user_id.to_i) %></td>

	</tr>

<% end -%>

</tbody>

</table>

<p><%= submit_tag(l(:button_update)) %></p>

<% end %>

<% end %>

<span class="author"><%= authoring(@changeset.committed_on, @changeset.author) %></span></p>

class AddChangesetsUserId < ActiveRecord::Migration

  def self.up

    add_column :changesets, :user_id, :integer, :default => nil

  end

  def self.down

    remove_column :changesets, :user_id

  end

end

class PopulateChangesetsUserId < ActiveRecord::Migration

  def self.up

    committers = Changeset.connection.select_values("SELECT DISTINCT committer FROM #{Changeset.table_name}")

    committers.each do |committer|

      next if committer.blank?

      if committer.strip =~ /^([^<]+)(<(.*)>)?$/

        username, email = $1.strip, $3

        u = User.find_by_login(username)

        u ||= User.find_by_mail(email) unless email.blank?

        Changeset.update_all("user_id = #{u.id}", ["committer = ?", committer]) unless u.nil?

      end

    end

  end

  def self.down

    Changeset.update_all('user_id = NULL')

  end

end

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Vous pouvez sélectionner ou modifier l'utilisateur Redmine associé à chaque nom d'utilisateur figurant dans l'historique du dépôt.\nLes utilisateurs avec le même identifiant ou la même adresse mail seront automatiquement associés."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

text_repository_usernames_mapping: "Select ou update the Redmine user mapped to each username found in the repository log.\nUsers with the same Redmine and repository username or email are automatically mapped."

    map.permission :manage_repository, {:repositories => [:edit, :committers, :destroy]}, :require => :member

  user_id: 3

  user_id: 3

  user_id: 3

  user_id: 3

    - :manage_repository

  def test_committers

    @request.session[:user_id] = 2

    # add a commit with an unknown user

    Changeset.create!(:repository => Project.find(1).repository, :committer => 'foo', :committed_on => Time.now, :revision => 100, :comments => 'Committed by foo.')

    get :committers, :id => 1

    assert_response :success

    assert_template 'committers'

    assert_tag :td, :content => 'dlopper',

                    :sibling => { :tag => 'td',

                                  :child => { :tag => 'select', :attributes => { :name => 'committers[dlopper]' },

                                                                :child => { :tag => 'option', :content => 'Dave Lopper',

                                                                                              :attributes => { :value => '3', :selected => 'selected' }}}}

    assert_tag :td, :content => 'foo',

                    :sibling => { :tag => 'td',

                                  :child => { :tag => 'select', :attributes => { :name => 'committers[foo]' }}}

    assert_no_tag :td, :content => 'foo',

                       :sibling => { :tag => 'td',

                                     :descendant => { :tag => 'option', :attributes => { :selected => 'selected' }}}

  end

  def test_map_committers

    @request.session[:user_id] = 2

    # add a commit with an unknown user

    c = Changeset.create!(:repository => Project.find(1).repository, :committer => 'foo', :committed_on => Time.now, :revision => 100, :comments => 'Committed by foo.')

    assert_no_difference "Changeset.count(:conditions => 'user_id = 3')" do

      post :committers, :id => 1, :committers => { 'foo' => '2', 'dlopper' => '3'}

      assert_redirected_to '/repositories/committers/ecookbook'

      assert_equal User.find(2), c.reload.user

    end

  end

      assert_equal User.find_by_login('jsmith'), commit.user

  def test_manual_user_mapping

    assert_no_difference "Changeset.count(:conditions => 'user_id <> 2')" do

      c = Changeset.create!(:repository => @repository, :committer => 'foo', :committed_on => Time.now, :revision => 100, :comments => 'Committed by foo.')

      assert_nil c.user

      @repository.committer_ids = {'foo' => '2'}

      assert_equal User.find(2), c.reload.user

      # committer is now mapped

      c = Changeset.create!(:repository => @repository, :committer => 'foo', :committed_on => Time.now, :revision => 101, :comments => 'Another commit by foo.')

      assert_equal User.find(2), c.user

    end

  end

  def test_auto_user_mapping_by_username

    c = Changeset.create!(:repository => @repository, :committer => 'jsmith', :committed_on => Time.now, :revision => 100, :comments => 'Committed by john.')

    assert_equal User.find(2), c.user

  end

  def test_auto_user_mapping_by_email

    c = Changeset.create!(:repository => @repository, :committer => 'john <[email protected]>', :committed_on => Time.now, :revision => 100, :comments => 'Committed by john.')

    assert_equal User.find(2), c.user

  end