SoundSoftware Code Site

  def index

    @days = Setting.activity_days_default.to_i

    if params[:from]

      begin; @date_to = params[:from].to_date + 1; rescue; end

    end

    @date_from = @date_to - @days

    @with_subprojects = params[:with_subprojects].nil? ? Setting.display_subprojects_issues? : (params[:with_subprojects] == '1')

    @author = (params[:user_id].blank? ? nil : User.active.find(params[:user_id]))

                                                             :with_subprojects => @with_subprojects,

                                                             :author => @author)

    @activity.scope_select {|t| !params["show_#{t}"].nil?}

    @activity.scope = (@author.nil? ? :default : :all) if @activity.scope.empty?

    events = @activity.events(@date_from, @date_to)

    if events.empty? || stale?(:etag => [@activity.scope, @date_to, @date_from, @with_subprojects, @author, events.first, User.current, current_language])

      respond_to do |format|

          @events_by_day = events.group_by(&:event_date)

          render :layout => false if request.xhr?

        }

        }

      end

    end

  rescue ActiveRecord::RecordNotFound

    render_404

  end

  rescue ActiveRecord::RecordNotFound

    render_404

  end

end

class AdminController < ApplicationController

  layout 'admin'

  before_filter :require_admin

  helper :sort

  include SortHelper	

  def projects

    @status = params[:status] ? params[:status].to_i : 1

    c = ARCondition.new(@status == 0 ? "status <> 0" : ["status = ?", @status])

    unless params[:name].blank?

      name = "%#{params[:name].strip.downcase}%"

      c << ["LOWER(identifier) LIKE ? OR LOWER(name) LIKE ?", name, name]

    end

    @projects = Project.find :all, :order => 'lft',

                                   :conditions => c.conditions

    render :action => "projects", :layout => false if request.xhr?

  end

  def plugins

    @plugins = Redmine::Plugin.all

  end

  # Loads the default configuration

  # (roles, trackers, statuses, workflow, enumerations)

  def default_configuration

    end

    redirect_to :action => 'index'

  end

  def test_email

    raise_delivery_errors = ActionMailer::Base.raise_delivery_errors

    # Force ActionMailer to raise delivery errors so we can catch it

    ActionMailer::Base.raise_delivery_errors = raise_delivery_errors

    redirect_to :controller => 'settings', :action => 'edit', :tab => 'notifications'

  end

  def info

    @db_adapter_name = ActiveRecord::Base.connection.adapter_name

    @checklist = [

      [:text_file_repository_writable, File.writable?(Attachment.storage_path)],

    ]

end

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

  layout 'base'

  exempt_from_layout 'builder', 'rsb'

  # Remove broken cookie after upgrade from 0.8.x (#4292)

  # See https://rails.lighthouseapp.com/projects/8994/tickets/3360

  # TODO: remove it when Rails is fixed

  before_filter :delete_broken_cookies

  def delete_broken_cookies

    if cookies['_redmine_session'] && cookies['_redmine_session'] !~ /--/

      redirect_to home_path

      return false

    end

  end

  before_filter :user_setup, :check_if_login_required, :set_localization

  filter_parameter_logging :password

  protect_from_forgery

  rescue_from ActionController::InvalidAuthenticityToken, :with => :invalid_authenticity_token

  include Redmine::Search::Controller

  include Redmine::MenuManager::MenuController

  helper Redmine::MenuManager::MenuHelper

  Redmine::Scm::Base.all.each do |scm|

    require_dependency "repository/#{scm.underscore}"

  end

    # Find the current user

    User.current = find_current_user

  end

  # Returns the current user or nil if no user is logged in

  # and starts a session if needed

  def find_current_user

      User.current = User.anonymous

    end

  end

  # check if login is globally required to access the application

  def check_if_login_required

    # no check needed if user is already logged in

    return true if User.current.logged?

    require_login if Setting.login_required?

  def set_localization

    lang = nil

    if User.current.logged?

    lang ||= Setting.default_language

    set_language_if_valid(lang)

  end

  def require_login

    if !User.current.logged?

      # Extract only the basic url parameters on non-GET requests

    end

    true

  end

  def deny_access

    User.current.logged? ? render_403 : require_login

  end

  # Finds and sets @project based on @object.project

  def find_project_from_association

    render_404 unless @object.present?

    @project = @object.project

  rescue ActiveRecord::RecordNotFound

    render_404

  def find_issues

    @issues = Issue.find_all_by_id(params[:id] || params[:ids])

    raise ActiveRecord::RecordNotFound if @issues.empty?

    @projects = @issues.collect(&:project).compact.uniq

    @project = @projects.first if @projects.size == 1

  rescue ActiveRecord::RecordNotFound

    render_404

  end

  # Check if project is unique before bulk operations

  def check_project_uniqueness

    unless @project

      return false

    end

  end

  # make sure that the user is a member of the project (or admin) if project is private

  # used as a before_filter for actions that do not require any particular permission on the project

  def check_project_privacy

      end

    end

    redirect_to default

  end

  def render_403(options={})

    @project = nil

    render_error({:message => :notice_not_authorized, :status => 403}.merge(options))

    return false

  end

  def render_404(options={})

    render_error({:message => :notice_file_not_found, :status => 404}.merge(options))

    return false

  end

  # Renders an error response

  def render_error(arg)

    arg = {:message => arg} unless arg.is_a?(Hash)

    @message = arg[:message]

    @message = l(@message) if @message.is_a?(Symbol)

    @status = arg[:status] || 500

    respond_to do |format|

      format.html {

        render :template => 'common/error', :layout => use_layout, :status => @status

  def use_layout

    request.xhr? ? false : 'base'

  end

  def invalid_authenticity_token

    if api_request?

      logger.error "Form authenticity token is missing or is invalid. API calls must include a proper Content-type header (text/xml or text/json)."

    end

    render_error "Invalid form authenticity token."

  end

    @items = items || []

    @items.sort! {|x,y| y.event_datetime <=> x.event_datetime }

    @items = @items.slice(0, Setting.feeds_limit.to_i)

    @title = options[:title] || Setting.app_title

    render :template => "common/feed.atom.rxml", :layout => false, :content_type => 'application/atom+xml'

  end

  def self.accept_key_auth(*actions)

    actions = actions.flatten.map(&:to_s)

    write_inheritable_attribute('accept_key_auth_actions', actions)

  end

  def accept_key_auth_actions

    self.class.read_inheritable_attribute('accept_key_auth_actions') || []

  end

  # Returns the number of objects that should be displayed

  # on the paginated list

  def per_page_option

      offset = 0 if offset < 0

    end

    offset ||= 0

    [offset, limit]

  end

  # qvalues http header parser

  # code taken from webrick

  def parse_qvalues(value)

  rescue

    nil

  end

  # Returns a string that can be used as filename value in Content-Disposition header

  def filename_for_content_disposition(name)

    request.env['HTTP_USER_AGENT'] =~ %r{MSIE} ? ERB::Util.url_encode(name) : name

  end

  def api_request?

    %w(xml json).include? params[:format]

  end

  # Returns the API key present in the request

  def api_key_from_request

    if params[:key].present?

    )

    render options

  end

  # Overrides #default_template so that the api template

  # is used automatically if it exists

  def default_template(action_name = self.action_name)

    end

    super

  end

  # Overrides #pick_layout so that #render with no arguments

  # doesn't use the layout for api requests

  def pick_layout(*args)

# Redmine - project management software

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

  before_filter :find_project

  before_filter :file_readable, :read_authorize, :except => :destroy

  before_filter :delete_authorize, :only => :destroy

  verify :method => :post, :only => :destroy

  def show

    if @attachment.is_diff?

      @diff = File.new(@attachment.diskfile, "rb").read

      download

    end

  end

  def download

    if @attachment.container.is_a?(Version) || @attachment.container.is_a?(Project)

      @attachment.increment_download

    end

    # images are sent inline

    send_file @attachment.diskfile, :filename => filename_for_content_disposition(@attachment.filename),

                                    :disposition => (@attachment.image? ? 'inline' : 'attachment')

  end

  def destroy

    # Make sure association callbacks are called

    @attachment.container.attachments.delete(@attachment)

  rescue ::ActionController::RedirectBackError

    redirect_to :controller => 'projects', :action => 'show', :id => @project

  end

private

  def find_project

    @attachment = Attachment.find(params[:id])

  rescue ActiveRecord::RecordNotFound

    render_404

  end

  # Checks that the file exists and is readable

  def file_readable

    @attachment.readable? ? true : render_404

  end

  def read_authorize

    @attachment.visible? ? true : deny_access

  end

  def delete_authorize

    @attachment.deletable? ? true : deny_access

  end

  def detect_content_type(attachment)

    content_type = attachment.content_type

    if content_type.blank?

class CalendarsController < ApplicationController

  menu_item :calendar

  before_filter :find_optional_project

    render :action => 'show', :layout => false if request.xhr?

  end

end

class ContextMenusController < ApplicationController

  helper :watchers

  def issues

    @issues = Issue.visible.all(:conditions => {:id => params[:ids]}, :include => :project)

    render :layout => false

  end

end

      flash[:notice] = l(:notice_successful_create)

      call_hook(:controller_custom_fields_new_after_save, :params => params, :custom_field => @custom_field)

      redirect_to :action => 'index', :tab => @custom_field.class.name

    end

  end

  def edit

      flash[:notice] = l(:notice_successful_update)

      call_hook(:controller_custom_fields_edit_after_save, :params => params, :custom_field => @custom_field)

      redirect_to :action => 'index', :tab => @custom_field.class.name

    end

  end

  def destroy

      # No associated objects

      @enumeration.destroy

      redirect_to :action => 'index'

    elsif params[:reassign_to_id]

      if reassign_to = @enumeration.class.find_by_id(params[:reassign_to_id])

        @enumeration.destroy(reassign_to)

        redirect_to :action => 'index'

      end

    end

    @enumerations = @enumeration.class.find(:all) - [@enumeration]

                'created_on' => "#{Attachment.table_name}.created_on",

                'size' => "#{Attachment.table_name}.filesize",

                'downloads' => "#{Attachment.table_name}.downloads"

    @containers = [ Project.find(@project.id, :include => :attachments, :order => sort_clause)]

    @containers += @project.versions.find(:all, :include => :attachments, :order => sort_clause).sort.reverse

    render :layout => !request.xhr?

class GanttsController < ApplicationController

  menu_item :gantt

  before_filter :find_optional_project

      format.pdf  { send_data(@gantt.to_pdf, :type => 'application/pdf', :filename => "#{basename}.pdf") }

    end

  end

end

  def autocomplete_for_user

    @group = Group.find(params[:id])

    render :layout => false

  end

      # No issue assigned to this category

      @category.destroy

      redirect_to :controller => 'projects', :action => 'settings', :id => @project, :tab => 'categories'

    elsif params[:todo]

      reassign_to = @project.issue_categories.find_by_id(params[:reassign_to_id]) if params[:todo] == 'reassign'

      @category.destroy(reassign_to)

      redirect_to :controller => 'projects', :action => 'settings', :id => @project, :tab => 'categories'

    end

    @categories = @project.issue_categories - [@category]

  end

  default_search_scope :issues

  before_filter :find_issues, :check_project_uniqueness

  before_filter :authorize

  def new

    prepare_for_issue_move

    render :layout => false if request.xhr?

    @copy = params[:copy_options] && params[:copy_options][:copy]

    @allowed_projects = Issue.allowed_target_projects_on_move

    @target_project = @allowed_projects.detect {|p| p.id.to_s == params[:new_project_id]} if params[:new_project_id]

    @trackers = @target_project.trackers

    @available_statuses = Workflow.available_statuses(@project)

    @notes = params[:notes]

# Redmine - project management software

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

class IssuesController < ApplicationController

  menu_item :new_issue, :only => [:new, :create]

  default_search_scope :issues

  before_filter :find_issue, :only => [:show, :edit, :update]

  before_filter :find_issues, :only => [:bulk_edit, :bulk_update, :move, :perform_move, :destroy]

  before_filter :check_project_uniqueness, :only => [:move, :perform_move]

  accept_key_auth :index, :show, :create, :update, :destroy

  rescue_from Query::StatementInvalid, :with => :query_statement_invalid

  helper :journals

  helper :projects

  helper :custom_fields

  include CustomFieldsHelper

  helper :issue_relations

  verify :method => :post, :only => :create, :render => {:nothing => true, :status => :method_not_allowed }

  verify :method => :post, :only => :bulk_update, :render => {:nothing => true, :status => :method_not_allowed }

  verify :method => :put, :only => :update, :render => {:nothing => true, :status => :method_not_allowed }

  def index

    retrieve_query

    sort_init(@query.sort_criteria.empty? ? [['id', 'desc']] : @query.sort_criteria)

    sort_update(@query.sortable_columns)

    if @query.valid?

      case params[:format]

      when 'csv', 'pdf'

      else

        @limit = per_page_option

      end

      @issue_count = @query.issue_count

      @issue_pages = Paginator.new self, @issue_count, @limit, params['page']

      @offset ||= @issue_pages.current.offset

      @issues = @query.issues(:include => [:assigned_to, :tracker, :priority, :category, :fixed_version],

                              :limit => @limit)

      @issue_count_by_group = @query.issue_count_by_group

      respond_to do |format|

        format.html { render :template => 'issues/index.rhtml', :layout => !request.xhr? }

        format.api

  rescue ActiveRecord::RecordNotFound

    render_404

  end

  def show

    @journals = @issue.journals.find(:all, :include => [:user, :details], :order => "#{Journal.table_name}.created_on ASC")

    @journals.each_with_index {|j,i| j.indice = i+1}

    @journals.reverse! if User.current.wants_comments_in_reverse_order?

    @relations = @issue.relations.select {|r| r.other_issue(@issue) && r.other_issue(@issue).visible? }

    @allowed_statuses = @issue.new_statuses_allowed_to(User.current)

    @edit_allowed = User.current.allowed_to?(:edit_issues, @project)

    @priorities = IssuePriority.all

    respond_to do |format|

      format.html { render :template => 'issues/show.rhtml' }

      format.api

      end

    end

  end

  def edit

    update_issue_from_params

    set_flash_from_bulk_issue_save(@issues, unsaved_issue_ids)

    redirect_back_or_default({:controller => 'issues', :action => 'index', :project_id => @project})

  end

  def destroy

    @hours = TimeEntry.sum(:hours, :conditions => ['issue_id IN (?)', @issues]).to_f

    if @hours > 0

        return unless api_request?

      end

    end

    respond_to do |format|

      format.html { redirect_back_or_default(:action => 'index', :project_id => @project) }

      format.api  { head :ok }

private

  def find_issue

    @issue = Issue.find(params[:id], :include => [:project, :tracker, :status, :author, :priority, :category])

    @project = @issue.project

  rescue ActiveRecord::RecordNotFound

    render_404

  end

  def find_project

    project_id = (params[:issue] && params[:issue][:project_id]) || params[:project_id]

    @project = Project.find(project_id)

  rescue ActiveRecord::RecordNotFound

    render_404

  end

  # Used by #edit and #update to set some common instance variables

  # from the params

  # TODO: Refactor, not everything in here is needed by #edit

    @allowed_statuses = @issue.new_statuses_allowed_to(User.current)

    @priorities = IssuePriority.all

    @edit_allowed = User.current.allowed_to?(:edit_issues, @project)

    @time_entry.attributes = params[:time_entry]

    @notes = params[:notes] || (params[:issue].present? ? params[:issue][:notes] : nil)

    @issue.init_journal(User.current, @notes)

    @issue.safe_attributes = params[:issue]

    else

      @issue = @project.issues.visible.find(params[:id])

    end

    @issue.project = @project

    # Tracker must be set before custom field values

    @issue.tracker ||= @project.trackers.find((params[:issue] && params[:issue][:tracker_id]) || params[:tracker_id] || :first)

  menu_item :issues

  helper :issues

  helper :queries

  include QueriesHelper

  helper :sort

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

class MailHandlerController < ActionController::Base

  before_filter :check_credential

  verify :method => :post,

         :only => :index,

         :render => { :nothing => true, :status => 405 }

  # Submits an incoming email to MailHandler

  def index

    options = params.dup

      render :nothing => true, :status => :unprocessable_entity

    end

  end

  private

  def check_credential

    User.current = nil

    unless Setting.mail_handler_api_enabled? && params[:key].to_s == Setting.mail_handler_api_key

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

  before_filter :find_optional_project, :only => :index

  accept_key_auth :index

  def index

    case params[:format]

    when 'xml', 'json'

class PreviewsController < ApplicationController

  before_filter :find_project

# Redmine - project management software

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

      Mailer.with_deliveries(params[:notifications] == '1') do

        @project = Project.new

        @project.safe_attributes = params[:project]

        if validate_parent_id && @project.copy(@source_project, :only => params[:only])

          @project.set_allowed_parent!(params[:project]['parent_id']) if params[:project].has_key?('parent_id')

          flash[:notice] = l(:notice_successful_create)

    end

    @users_by_role = @project.users_by_role

    @news = @project.news.find(:all, :limit => 5, :include => [ :author, :project ], :order => "#{News.table_name}.created_on DESC")

    @trackers = @project.rolled_up_trackers

                                            :include => [:project, :status, :tracker],

                                            :conditions => cond)

    end

    @key = User.current.rss_key

    respond_to do |format|

    @query.project = params[:query_is_for_all] ? nil : @project

    @query.user = User.current

    @query.is_public = false unless User.current.allowed_to?(:manage_public_queries, @project) || User.current.admin?

    @query.column_names = nil if params[:default_columns]

    if request.post? && params[:confirm] && @query.save

      flash[:notice] = l(:notice_successful_create)

      redirect_to :controller => 'issues', :action => 'index', :project_id => @project, :query_id => @query

  def edit

    if request.post?

      @query.filters = {}

      @query.attributes = params[:query]

      @query.project = nil if params[:query_is_for_all]

      @query.is_public = false unless User.current.allowed_to?(:manage_public_queries, @project) || User.current.admin?

      @query.column_names = nil if params[:default_columns]

      if @query.save

# Redmine - project management software

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

  menu_item :repository

  menu_item :settings, :only => :edit

  default_search_scope :changesets

  before_filter :find_repository, :except => :edit

  before_filter :find_project, :only => :edit

  before_filter :authorize

  accept_key_auth :revisions

  rescue_from Redmine::Scm::Adapters::CommandFailed, :with => :show_error_command_failed

  def edit

    @repository = @project.repository

      @repository = Repository.factory(params[:repository_scm])

      @repository.project = @project if @repository

    end

    if request.post? && @repository

      @repository.save

    end

    render(:update) do |page|

      if @repository && !@project.repository

        page.replace_html "main-menu", render_main_menu(@project)

      end

    end

  end

  def committers

    @committers = @repository.committers

    @users = @project.users

  def destroy

    @repository.destroy

  end

  def show

    @repository.fetch_changesets if Setting.autofetch_changesets? && @path.empty?

    @entries = @repository.entries(@path, @rev)

    if request.xhr?

      @entries ? render(:partial => 'dir_list_content') : render(:nothing => true)

    else

    @content = @repository.cat(@path, @rev)

    (show_error_not_found; return) unless @content

      # Force the download

    else

      # Prevent empty lines when displaying a file with Windows style eol

      @content.gsub!("\r\n", "\n")

      @changeset = @repository.find_changeset_by_name(@rev)

  end

  def annotate

    @entry = @repository.entry(@path, @rev)

    (show_error_not_found; return) unless @entry

    else

      @diff_type = params[:type] || User.current.pref[:diff_type] || 'inline'

      @diff_type = 'inline' unless %w(inline sbs).include?(@diff_type)

      # Save diff type as user preference

      if User.current.logged? && @diff_type != User.current.pref[:diff_type]

        User.current.pref[:diff_type] = @diff_type

        User.current.preference.save

      end

      unless read_fragment(@cache_key)

        @diff = @repository.diff(@path, @rev, @rev_to)

        show_error_not_found unless @diff

      render_404

    end

  end

  private

  REV_PARAM_RE = %r{\A[a-f0-9]*\Z}i

    @path ||= ''

    @rev = params[:rev].blank? ? @repository.default_branch : params[:rev].strip

    @rev_to = params[:rev_to]

    unless @rev.to_s.match(REV_PARAM_RE) && @rev_to.to_s.match(REV_PARAM_RE)

      if @repository.branches.blank?

        raise InvalidRevisionParam

  def show_error_not_found

    render_error :message => l(:error_scm_not_found), :status => 404

  end

  # Handler for Redmine::Scm::Adapters::CommandFailed exception

  def show_error_command_failed(exception)

    render_error l(:error_scm_command_failed, exception.message)

  end

  def graph_commits_per_month(repository)

    @date_to = Date.today

    @date_from = @date_to << 11

    @date_from = Date.civil(@date_from.year, @date_from.month, 1)

    commits_by_month = [0] * 12

    commits_by_day.each {|c| commits_by_month[c.first.to_date.months_ago] += c.last }

    changes_by_month = [0] * 12

    changes_by_day.each {|c| changes_by_month[c.first.to_date.months_ago] += c.last }

    fields = []

    12.times {|m| fields << month_name(((Date.today.month - 1 - m) % 12) + 1)}

    graph = SVG::Graph::Bar.new(

      :height => 300,

      :width => 800,

      :graph_title => l(:label_commits_per_month),

      :show_graph_title => true

    )

    graph.add_data(

      :data => commits_by_month[0..11].reverse,

      :title => l(:label_revision_plural)

      :data => changes_by_month[0..11].reverse,

      :title => l(:label_change_plural)

    )

    graph.burn

  end

    changes_by_author = repository.changes.count(:all, :group => :committer)

    h = changes_by_author.inject({}) {|o, i| o[i.first] = i.last; o}

    fields = commits_by_author.collect {|r| r.first}

    commits_data = commits_by_author.collect {|r| r.last}

    changes_data = commits_by_author.collect {|r| h[r.first] || 0}

    fields = fields + [""]*(10 - fields.length) if fields.length<10

    commits_data = commits_data + [0]*(10 - commits_data.length) if commits_data.length<10

    changes_data = changes_data + [0]*(10 - changes_data.length) if changes_data.length<10

    # Remove email adress in usernames

    fields = fields.collect {|c| c.gsub(%r{<.+@.+>}, '') }

    graph = SVG::Graph::BarHorizontal.new(

      :height => 400,

      :width => 800,

      :graph_title => l(:label_commits_per_author),

      :show_graph_title => true

    )

    graph.add_data(

      :data => commits_data,

      :title => l(:label_revision_plural)

    )

    graph.add_data(

      :data => changes_data,

      :title => l(:label_change_plural)

    )

    graph.burn

  end

class Date

  def months_ago(date = Date.today)

    (date.year - self.year)*12 + (date.month - self.month)

      end

      flash[:notice] = l(:notice_successful_create)

      redirect_to :action => 'index'

    end

  end

  def edit

    if request.post? and @role.update_attributes(params[:role])

      flash[:notice] = l(:notice_successful_update)

      redirect_to :action => 'index'

    end

  end

  def destroy

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

class SettingsController < ApplicationController

  layout 'admin'

  before_filter :require_admin

  def index

      end

      flash[:notice] = l(:notice_successful_update)

      redirect_to :action => 'edit', :tab => params[:tab]

    end

  end

  def plugin

      Setting["plugin_#{@plugin.id}"] = params[:settings]

      flash[:notice] = l(:notice_successful_update)

      redirect_to :action => 'plugin', :id => @plugin.id

    end

  rescue Redmine::PluginNotFound

    render_404

  end

class TimelogController < ApplicationController

  menu_item :issues

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

  before_filter :authorize, :except => [:index]

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

  accept_key_auth :index, :show, :create, :update, :destroy

                'hours' => 'hours'

    cond = ARCondition.new

      cond << @project.project_condition(Setting.display_subprojects_issues?)

    end

    retrieve_date_range

    cond << ['spent_on BETWEEN ? AND ?', @from, @to]