SoundSoftware Code Site

# 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

  # Login request and validation

  def login

    if request.get?

    else

      authenticate_user

    end

  # Log out current user and redirect to welcome page

  def logout

  end

  # Lets user choose a new password

  def lost_password

    if params[:token]

      if @token.nil? || @token.expired?

        redirect_to home_url

        return

  # User self-registration

  def register

    if request.get?

      session[:auth_source_registration] = nil

      @ssamr_user_details = SsamrUserDetail.new

          session[:auth_source_registration] = nil

          self.logged_user = @user

          flash[:notice] = l(:notice_account_activated)

        end

      else

        @user.login = params[:user][:login]

  # Token based account activation

  def activate

    user = token.user

    user.activate

    if user.save

      token.destroy

  end

  def open_id_authenticate(openid_url)

      if result.successful?

        user = User.find_or_initialize_by_identity_url(identity_url)

        if user.new_record?

          # Self-registration off

          # Create on the fly

          user.login = registration['nickname'] unless registration['nickname'].nil?

      set_autologin_cookie(user)

    end

    call_hook(:controller_account_success_authentication_after, {:user => user })

  end

  def set_autologin_cookie(user)

    token = Token.create(:user => user, :action => 'autologin')

    cookie_options = {

      :value => token.value,

      :expires => 1.year.from_now,

      :secure => (Redmine::Configuration['autologin_cookie_secure'] ? true : false),

      :httponly => true

    }

  end

  # Onthefly creation failed, display the registration form to fill/fix attributes

    if user.save

      self.logged_user = user

      flash[:notice] = l(:notice_account_activated)

    else

      yield if block_given?

    end

# 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

# 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

  before_filter :require_admin

  helper :sort

  def index

    @no_configuration_data = Redmine::DefaultData::Loader::no_data?

  end

  def projects

    @status = params[:status] || 1

    scope = scope.like(params[:name]) if params[:name].present?

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

  end

        flash[:error] = l(:error_can_t_load_default_data, e.message)

      end

    end

  end

  def test_email

      flash[:error] = l(:notice_email_error, e.message)

    end

    ActionMailer::Base.raise_delivery_errors = raise_delivery_errors

  end

  def info

# 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

class ApplicationController < ActionController::Base

  include Redmine::I18n

  class_attribute :accept_api_auth_actions

  class_attribute :accept_rss_auth_actions

  protect_from_forgery

  def handle_unverified_request

    super

  end

  before_filter :session_expiration, :user_setup, :check_if_login_required, :set_localization

    user

  end

  def try_to_autologin

      # auto-login feature starts a new session

      if user

        reset_session

        start_user_session(user)

  # Logs out current user

  def logout_user

    if User.current.logged?

      Token.delete_all(["user_id = ? AND action = ?", User.current.id, 'autologin'])

      self.logged_user = nil

    end

    render_404

  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

# 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

    @attachment = Attachment.new(:file => request.raw_post)

    @attachment.author = User.current

    @attachment.filename = params[:filename].presence || Redmine::Utils.random_hex(16)

    end

  end

    if @attachment.container.respond_to?(:init_journal)

      @attachment.container.init_journal(User.current)

    end

  end

  def toggle_active

  # Checks that the file exists and is readable

  def file_readable

  end

  def read_authorize

# 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

  menu_item :ldap_authentication

  before_filter :require_admin

  def index

  end

  def new

    klass_name = params[:type] || 'AuthSourceLdap'

    @auth_source = AuthSource.new_subclass_instance(klass_name, params[:auth_source])

  end

  def create

    @auth_source = AuthSource.new_subclass_instance(params[:type], params[:auth_source])

    if @auth_source.save

      flash[:notice] = l(:notice_successful_create)

    else

      render :action => 'new'

    end

  end

  def edit

  end

  def update

    if @auth_source.update_attributes(params[:auth_source])

      flash[:notice] = l(:notice_successful_update)

    else

      render :action => 'edit'

    end

  end

  def test_connection

    begin

      @auth_source.test_connection

      flash[:notice] = l(:notice_successful_connection)

    rescue Exception => e

      flash[:error] = l(:error_unable_to_connect, e.message)

    end

  end

  def destroy

      @auth_source.destroy

      flash[:notice] = l(:notice_successful_delete)

    end

  end

end

# 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

    q = (params[:q] || params[:term]).to_s.strip

    if q.present?

      scope = (params[:scope] == "all" || @project.nil? ? Issue : @project.issues).visible

      end

      @issues.compact!

    end

    render :layout => false

# 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

    respond_to do |format|

      format.html {

        sort_init 'updated_on', 'desc'

                    'replies' => "#{Message.table_name}.replies_count",

                    'updated_on' => "COALESCE(last_replies_messages.created_on, #{Message.table_name}.created_on)"

        @topic_count = @board.topics.count

        @topics =  @board.topics.

          reorder("#{Message.table_name}.sticky DESC").

          includes(:last_reply).

          order(sort_clause).

          preload(:author, {:last_reply => :author}).

          all

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

      }

      format.atom {

        render_feed(@messages, :title => "#{@project}: #{@board}")

      }

    end

private

  def redirect_to_settings_in_projects

  end

  def find_board_if_available

# 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

# 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

      flash[:notice] = l(:label_comment_added)

    end

  end

  def destroy

    @news.comments.find(params[:comment_id]).destroy

  end

  private

# 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

  def issues

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

    if (@issues.size == 1)

      @issue = @issues.first

    end

  def time_entries

    @time_entries = TimeEntry.all(

       :conditions => {:id => params[:ids]}, :include => :project)

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

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

    @activities = TimeEntryActivity.shared.active

# 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

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

  def index

    @tab = params[:tab] || 'IssueCustomField'

  end

  end

  def create

      flash[:notice] = l(:notice_successful_create)

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

    else

      render :action => 'new'

    end

  end

  def update

      flash[:notice] = l(:notice_successful_update)

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

    else

      render :action => 'edit'

    end

  end

  def destroy

  end

  private

    @custom_field = CustomField.new_subclass_instance(params[:type], params[:custom_field])

    if @custom_field.nil?

      render_404

    end

  end

# 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

  def index

    @sort_by = %w(category date title author).include?(params[:sort_by]) ? params[:sort_by] : 'category'

    case @sort_by

    when 'date'

      @grouped = documents.group_by {|d| d.updated_on.to_date }

  end

  def show

  end

  def new

    if @document.save

      render_attachment_warning_if_needed(@document)

      flash[:notice] = l(:notice_successful_create)

    else

      render :action => 'new'

    end

    @document.safe_attributes = params[:document]

    if request.put? and @document.save

      flash[:notice] = l(:notice_successful_update)

    else

      render :action => 'edit'

    end

  def destroy

    @document.destroy if request.delete?

  end

  def add_attachment

    if attachments.present? && attachments[:files].present? && Setting.notified_events.include?('document_added')

      Mailer.attachments_added(attachments[:files]).deliver

    end

  end

end

# 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

  def create

    if request.post? && @enumeration.save

      flash[:notice] = l(:notice_successful_create)

    else

      render :action => 'new'

    end

  def update

    if request.put? && @enumeration.update_attributes(params[:enumeration])

      flash[:notice] = l(:notice_successful_update)

    else

      render :action => 'edit'

    end

    if !@enumeration.in_use?

      # No associated objects

      @enumeration.destroy

      return

    elsif params[:reassign_to_id]

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

        @enumeration.destroy(reassign_to)

        return

      end

    end

  end

  private

# 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

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

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

    render :layout => !request.xhr?

  end

# 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

# 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

    @group.destroy

    respond_to do |format|

      format.api  { render_api_ok }

    end

  end

    @users = User.find_all_by_id(params[:user_id] || params[:user_ids])

    @group.users << @users if request.post?

    respond_to do |format|

      format.js

      format.api { render_api_ok }

    end

  def remove_user

    @group.users.delete(User.find(params[:user_id])) if request.delete?

    respond_to do |format|

      format.js

      format.api { render_api_ok }

    end

  end

  def autocomplete_for_user

  end

  def edit_membership

    @membership = Member.edit_membership(params[:membership_id], params[:membership], @group)

    @membership.save if request.post?

    respond_to do |format|

      format.js

    end

  end

  def destroy_membership

    Member.find(params[:membership_id]).destroy if request.post?

    respond_to do |format|

      format.js

    end

  end

# 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

  def index

    respond_to do |format|

      format.api { @categories = @project.issue_categories.all }

    end

  end

  def show

    respond_to do |format|

      format.api

    end

  end

      respond_to do |format|

        format.html do

          flash[:notice] = l(:notice_successful_create)

        end

        format.js

        format.api { render :action => 'show', :status => :created, :location => issue_category_path(@category) }

      respond_to do |format|

        format.html {

          flash[:notice] = l(:notice_successful_update)

        }

        format.api { render_api_ok }

      end

      end

      @category.destroy(reassign_to)

      respond_to do |format|

        format.api { render_api_ok }

      end

      return

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

  end

  # Wrap ApplicationController's find_model_object method to set

  # @category instead of just @issue_category

  def find_model_object

# 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

    saved = @relation.save

    respond_to do |format|

      format.js {

      }

      format.api {

        if saved

    @relation.destroy

    respond_to do |format|

      format.js

      format.api  { render_api_ok }

    end

# 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

  def index

    respond_to do |format|

      format.html {

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

      }

      format.api {

    @issue_status = IssueStatus.new(params[:issue_status])

    if request.post? && @issue_status.save

      flash[:notice] = l(:notice_successful_create)

    else

      render :action => 'new'

    end

    @issue_status = IssueStatus.find(params[:id])

    if request.put? && @issue_status.update_attributes(params[:issue_status])

      flash[:notice] = l(:notice_successful_update)

    else

      render :action => 'edit'

    end

  def destroy

    IssueStatus.find(params[:id]).destroy

  rescue

    flash[:error] = l(:error_unable_delete_issue_status)

  def update_issue_done_ratio

    if request.post? && IssueStatus.update_issue_done_ratios

    else

      flash[:error] =  l(:error_issue_done_ratios_not_updated)

    end

  end

end

# 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

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

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

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

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

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

  accept_rss_auth :index, :show

  accept_api_auth :index, :show, :create, :update, :destroy

      end

      @issue_count = @query.issue_count

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

                              :order => sort_clause,

                              :offset => @offset,

          Issue.load_visible_relations(@issues) if include_in_api_response?('relations')

        }

        format.atom { render_feed(@issues, :title => "#{@project || Setting.app_title}: #{l(:label_issue_plural)}") }

      end

    else

      respond_to do |format|

  def new

    respond_to do |format|

      format.html { render :action => 'new', :layout => !request.xhr? }

    end

  end

        format.html {

          render_attachment_warning_if_needed(@issue)

          flash[:notice] = l(:notice_issue_successful_create, :id => view_context.link_to("##{@issue.id}", issue_path(@issue), :title => @issue.subject))

        }

        format.api  { render :action => 'show', :status => :created, :location => issue_url(@issue) }

      end

      flash[:notice] = l(:notice_successful_update) unless @issue.current_journal.new_record?

      respond_to do |format|

        format.api  { render_api_ok }

      end

    else

    end

  end

  # Bulk edit/copy a set of issues

  def bulk_edit

    @issues.sort!

    if params[:follow]

      if @issues.size == 1 && moved_issues.size == 1

      elsif moved_issues.map(&:project).uniq.size == 1

      end

    else

    end

  end

      end

    end

    respond_to do |format|

      format.api  { render_api_ok }

    end

  end

# 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

      @journal.destroy if @journal.details.empty? && @journal.notes.blank?

      call_hook(:controller_journals_edit_post, { :journal => @journal, :params => params})

      respond_to do |format|

        format.js { render :action => 'update' }

      end

    else

# 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

# 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

      format.api {

        @offset, @limit = api_offset_and_limit

        @member_count = @project.member_principals.count

        @members =  @project.member_principals.all(

          :order => "#{Member.table_name}.id",

          :limit  =>  @limit,

# 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

  menu_item :boards

  default_search_scope :messages

  before_filter :find_board, :only => [:new, :preview]

  before_filter :find_message, :except => [:new, :preview]

  before_filter :authorize, :except => [:preview, :edit, :destroy]

    end

    @reply_count = @topic.children.count

    @reply = Message.new(:subject => "RE: #{@message.subject}")

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

  def preview

    message = @board.messages.find_by_id(params[:id])

    @text = (params[:message] || params[:reply])[:content]

    @previewed = message

    render :partial => 'common/preview'

# 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

        @user.notified_project_ids = (@user.mail_notification == 'selected' ? params[:notified_project_ids] : [])

        set_language_if_valid @user.language

        flash[:notice] = l(:notice_account_updated)

        return

      end

    end

  def destroy

    @user = User.current

    unless @user.own_account_deletable?

      return

    end

    @user = User.current

    unless @user.change_password_allowed?

      flash[:error] = l(:notice_can_t_change_password)

      return

    end

    if request.post?

        @user.password, @user.password_confirmation = params[:new_password], params[:new_password_confirmation]

        if @user.save

          flash[:notice] = l(:notice_account_password_updated)

        end

      else

        flash[:error] = l(:notice_account_wrong_password)

      User.current.rss_key

      flash[:notice] = l(:notice_feeds_access_key_reseted)

    end

  end

  # Create a new API key

      User.current.api_key

      flash[:notice] = l(:notice_api_access_key_reseted)

    end

  end

  # User's page layout configuration

      @user.pref[:my_page_layout] = layout

      @user.pref.save

    end

  end

  # Remove a block to user's page

    %w(top left right).each {|f| (layout[f] ||= []).delete block }

    @user.pref[:my_page_layout] = layout

    @user.pref.save

  end

  # Change blocks order on user's page

# 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

    scope = @project ? @project.news.visible : News.visible

    @news_count = scope.count

    @newss = scope.all(:include => [:author, :project],

                                       :order => "#{News.table_name}.created_on DESC",

                                       :offset => @offset,

    if @news.save

      render_attachment_warning_if_needed(@news)

      flash[:notice] = l(:notice_successful_create)

    else

      render :action => 'new'

    end

    if @news.save

      render_attachment_warning_if_needed(@news)

      flash[:notice] = l(:notice_successful_update)

    else

      render :action => 'edit'

    end

  def destroy

    @news.destroy

  end

  private

# 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

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

class PreviewsController < ApplicationController

  def issue

    @issue = @project.issues.find_by_id(params[:id]) unless params[:id].blank?

    if @issue

      @description = params[:issue] && params[:issue][:description]

      if @description && @description.gsub(/(\r?\n|\n\r?)/, "\n") == @issue.description.to_s.gsub(/(\r?\n|\n\r?)/, "\n")

        @description = nil

  def news

    if params[:id].present? && news = News.visible.find_by_id(params[:id])

      @previewed = news

    end

    @text = (params[:news] ? params[:news][:description] : nil)

    render :partial => 'common/preview'

# 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

      flash[:notice] = l(:notice_successful_update)

    end

  end

  def destroy

      time_entry_activity.destroy(time_entry_activity.parent)

    end

    flash[:notice] = l(:notice_successful_update)

  end

end

# 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

  helper :repositories

  include RepositoriesHelper

  include ProjectsHelper

  include ActivitiesHelper

  helper :activities

      format.api  {

        @offset, @limit = api_offset_and_limit

        @project_count = Project.visible.count

      }

      format.atom {

        render_feed(projects, :title => "#{Setting.app_title}: #{l(:label_project_latest)}")

      }

    end

  end

  def new

    @trackers = Tracker.sorted.all

    @project = Project.new

    @project.safe_attributes = params[:project]

  end

  def create

    @trackers = Tracker.sorted.all

    @project = Project.new

    @project.safe_attributes = params[:project]

      respond_to do |format|

        format.html {

          flash[:notice] = l(:notice_successful_create)

        }

        format.api  { render :action => 'show', :status => :created, :location => url_for(:controller => 'projects', :action => 'show', :id => @project.id) }

      end

        format.api  { render_validation_errors(@project) }

      end

    end

  end

  def copy

    @trackers = Tracker.sorted.all

    @source_project = Project.find(params[:id])

    if request.get?

      @project = Project.copy_from(@source_project)

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