Redmine

    @users = User.active.find(:all, :order => :login)

    @roles = Role.find(:all, :order => :name)

    unless @user # create user

      if Setting.mail_handler_create_users_from_incoming_mails.to_i != 0 # creates a user and assigns him to a project

        @user = create_user(email)

        return false unless @user

        return false unless create_role(@user)

      elsif Setting.mail_handler_assign_unknown_addresses_to_user.to_i != 0 # use default users, needs :add_issue right on project

        unless @user = User.find_by_id(Setting.mail_handler_assign_unknown_addresses_to_user.to_i)

          logger.info "MailHandler: could not find User with id [#{Setting.mail_handler_assign_unknown_addresses_to_user.to_i}] to assign sender #{email.from.first}" if logger && loggger.info

          return false

        end

      else

        # unknown user and no values specified to handle unknown mails

        logger.info "MailHandler: email submitted by unknown user [#{email.from.first}] (change Settings in incoming E-Mail tab for default behaviour)" if logger && logger.info

        return false

      end

  protected

  def target_project

    # TODO: other ways to specify project:

    # * parse the email To field

    # * specific project (eg. Setting.mail_handler_target_project)

    target = Project.find_by_identifier(get_keyword(:project))

    raise MissingInformation.new('Unable to determine target project') if target.nil?

    target

  end

  # creates a user from email address and sets the status depending on the configured actions

  def create_user(email)

    new_user = User.new

    new_user.mail = email.from.first.to_s

    new_user.admin = false

    email_user_name = email.from.first.to_s.split('@').first

    new_user.login = if !User.find_by_login(email_user_name) # set login to the email address without domain or if it exists to the full email

      email_user_name

    else

      email.from.first.to_s

    end

    new_user.status = User::STATUS_REGISTERED

    new_user.firstname = email_user_name.split('.').first

    new_user.lastname = email_user_name.split('.').last

    password = Token.generate_token_value(8)

    new_user.password = password

    new_user.password_confirmation = password

    case Setting.mail_handler_create_users_from_incoming_mails

    when '1' || '2'

      token = Token.new(:user => new_user, :action => "register")

      Mailer.deliver_register(token) if new_user.save and token.save

      Mailer.deliver_account_information(new_user, password)

    when '3'

      new_user.status = User::STATUS_ACTIVE

      new_user.last_login_on = Time.now

      if new_user.save

        Mailer.deliver_account_information(new_user, password, :notice_account_register_done)

      else

        logger.info "could not create user #{new_user}" if logger and logger.info

        return false

      end

    else

      Mailer.deliver_account_activation_request(new_user)

      Mailer.deliver_account_information(new_user, password, :notice_account_pending)

    end

    return new_user

  end

  # creates a member on the target_project for the given user with the configured role

  def create_role(user)

    # Roles need right for add_issue

    if Setting.mail_handler_role_to_add_users_to_project.to_i != 0

      if Role.find_by_id(Setting.mail_handler_role_to_add_users_to_project.to_i)

        member = Member.new(

          :user_id => user.id,

          :project_id => self.target_project.id,

          :role_id => Setting.mail_handler_role_to_add_users_to_project.to_i

        )

        unless member.save

          logger.info "could not create Role for user #{user.login} and project #{self.target_project.name}" if logger and logger.info

          return false

        end

      else

        logger.info "could not assing #{user} to #{self.target_project.name}, missing Role id: #{Setting.mail_handler_role_to_add_users_to_project}" if logger and logger.info

        return false

      end

    end

    return true

  end

    # check permissions

          :content => plain_text_body)

          :file => attachment,

          :author => user,

          :content_type => attachment.content_type)

  def account_information(user, password, information = '')

         :information => information,

  def self.generate_token_value(length = 40)

    length.times { |i| token_value << chars[rand(chars.size-1)] }

  <p><%= l(:mail_body_account_information_external, @user.auth_source.name) %></p>

  <p><%= l(:mail_body_account_information) %>:</p>

  <ul>

  </ul>

<% if @information -%>

  <p><%= l(@information) %></p>

<% end -%>

<% if @information -%>

  <%= l(@information) %>

<% end -%>

  <div class="box tabular settings">

    <p><label><%= l(:setting_mail_handler_api_enabled) %></label>

      <%= check_box_tag 'settings[mail_handler_api_enabled]', 1, Setting.mail_handler_api_enabled?,

        :onclick => "if (this.checked) { Form.Element.enable('settings_mail_handler_api_key'); } else { Form.Element.disable('settings_mail_handler_api_key'); }" %>

      <%= hidden_field_tag 'settings[mail_handler_api_enabled]', 0 %></p>

    <p><label><%= l(:setting_mail_handler_api_key) %></label>

      <%= text_field_tag 'settings[mail_handler_api_key]', Setting.mail_handler_api_key,

        :size => 30,

        :id => 'settings_mail_handler_api_key',

        :disabled => !Setting.mail_handler_api_enabled? %>

      <%= link_to_function l(:label_generate_key), "if ($('settings_mail_handler_api_key').disabled == false) { $('settings_mail_handler_api_key').value = randomKey(20) }" %></p>

    <p>

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

      <%= select_tag 'settings[mail_handler_create_users_from_incoming_mails]',

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

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

          [l(:label_registration_manual_activation), "2"],

          [l(:label_registration_automatic_activation), "3"]

        ], Setting.mail_handler_create_users_from_incoming_mails ),

        :onChange => "if (this.options[this.selectedIndex].value == \"0\") { Form.Element.enable('settings_mail_handler_assign_unknown_addresses_to_user'); } else { Form.Element.disable('settings_mail_handler_assign_unknown_addresses_to_user'); }"

    %>

    </p>

    <p>

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

      <%= select(:settings, :mail_handler_role_to_add_users_to_project, @roles.collect {|p| [ p.name, p.id ] },

        { :include_blank => true, :selected => Setting.mail_handler_role_to_add_users_to_project.to_i }

      ) %>

    </p>

    <p>

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

      <%= select(:settings, :mail_handler_assign_unknown_addresses_to_user, @users.collect {|p| [ p.login, p.id ] },

        { :include_blank => true, :selected => Setting.mail_handler_assign_unknown_addresses_to_user.to_i },

        { :disabled => Setting.mail_handler_create_users_from_incoming_mails.to_i == 0}

      ) %>

    </p>

  </div>

  <%= submit_tag l(:button_save) %>

  setting_mail_handler_create_users_from_incoming_mails: Erstelle Benutzer aus eingehenden E-Mails

  setting_mail_handler_assign_unknown_addresses_to_user: Unbekannte Absender folgendem Benutzer zuordnen

  setting_mail_handler_role_to_add_users_to_project: Rolle für neue Benutzer

  setting_mail_handler_create_users_from_incoming_mails: Create users from incoming E-Mails

  setting_mail_handler_assign_unknown_addresses_to_user: Assign Unknown addresses to the following User

  setting_mail_handler_role_to_add_users_to_project: Role for new Users

  default:

mail_handler_create_users_from_incoming_mails:

  default: 0

mail_handler_assign_unknown_addresses_to_user:

  default: 0

mail_handler_role_to_add_users_to_project:

  default: 0

                   :messages,

                   :settings

  def test_should_create_new_user_and_assign_to_project

    issue = submit_email('ticket_with_new_user.eml')

    assert issue.is_a?(Issue)

    assert !issue.new_record?

    assert_equal issue.subject, 'New ticker from new user'

    assert_equal 'onlinestore', issue.project.name.downcase

    assert_equal 'jjins', issue.author.login

    assert_equal 'jjins@somenet.foo', issue.author.mail

    creator = User.find_by_login('jjins')

    assert_not_nil creator

    member = Member.find(:first, :conditions => {:project_id => issue.project.id, :user_id => creator.id})

    assert_not_nil member

    assert_equal 'Reporter', member.role.name

  end