# app/models/stuff_to_do.rb
class StuffToDo < ActiveRecord::Base
  def self.conditions_for_available(filter_by, record_id)
    case filter_by
    when :user
      ["assigned_to_id = ? AND #{IssueStatus.table_name}.is_closed = ?", record_id, false ]
    when :status
      ["#{IssueStatus.table_name}.id = (?) AND #{IssueStatus.table_name}.is_closed = ?", record_id, false ]
    when :priority
      ["#{Enumeration.table_name}.id = (?) AND #{IssueStatus.table_name}.is_closed = ?", record_id, false ]
    end
  end
end

class StuffToDo < ActiveRecord::Base
  def self.conditions_for_available(filter_by, record_id)
    conditions_builder = ARCondition.new
    conditions_builder.add(["#{IssueStatus.table_name}.is_closed = ?", false ])

    case filter_by
    when :user
      conditions_builder.add(["assigned_to_id = ?", record_id])
    when :status
      conditions_builder.add(["#{IssueStatus.table_name}.id = (?)", record_id])
    when :priority
      conditions_builder.add(["#{Enumeration.table_name}.id = (?)", record_id])
    end

    conditions_builder.conditions
  end
end

# app/models/stuff_to_do.rb
class StuffToDo < ActiveRecord::Base
  def self.available(user, filter = { })
    if filter.nil? || filter.empty?
      return []
    elsif filter[:user]
      user = filter[:user]
      issues = Issue.find(:all,
                          :include => :status,
                          :conditions => ["assigned_to_id = ? AND #{IssueStatus.table_name}.is_closed = ?",user.id, false ],
                          :order => 'created_on DESC')
    elsif filter[:status]
      status = filter[:status]
      issues = Issue.find(:all,
                          :include => :status,
                          :conditions => ["#{IssueStatus.table_name}.id = (?) AND #{IssueStatus.table_name}.is_closed = ?", status.id, false ],
                          :order => 'created_on DESC')
    elsif filter[:priority]
      priority = filter[:priority]
      issues = Issue.find(:all,
                          :include => [:status, :priority],
                          :conditions => ["#{Enumeration.table_name}.id = (?) AND #{IssueStatus.table_name}.is_closed = ?", priority.id, false ],
                          :order => 'created_on DESC')
    elsif filter[:projects]
      # TODO: remove 'issues' naming
      issues = active_and_visible_projects.sort
    end
    next_issues = StuffToDo.find(:all, :conditions => { :user_id => user.id }).collect(&:stuff)

    
    return issues - next_issues
  end

end

class StuffToDo < ActiveRecord::Base
  def self.available(user, filter = { })
    if filter.nil? || filter.empty?
      return []
    elsif filter[:user]
      user = filter[:user]
      issues = Issue.find(:all,
                          :include => :status,
                          :conditions => conditions_for_available(:user, user.id),
                          :order => 'created_on DESC')
    elsif filter[:status]
      status = filter[:status]
      issues = Issue.find(:all,
                          :include => :status,
                          :conditions => conditions_for_available(:status, status.id),
                          :order => 'created_on DESC')
    elsif filter[:priority]
      priority = filter[:priority]
      issues = Issue.find(:all,
                          :include => [:status, :priority],
                          :conditions => conditions_for_available(:priority, priority.id),
                          :order => 'created_on DESC')
    elsif filter[:projects]
      # TODO: remove 'issues' naming
      issues = active_and_visible_projects.sort
    end
    next_issues = StuffToDo.find(:all, :conditions => { :user_id => user.id }).collect(&:stuff)

    
    return issues - next_issues
  end

  private

  def self.conditions_for_available(filter_by, record_id)
    case filter_by
    when :user
      ["assigned_to_id = ? AND #{IssueStatus.table_name}.is_closed = ?", record_id, false ]
    when :status
      ["#{IssueStatus.table_name}.id = (?) AND #{IssueStatus.table_name}.is_closed = ?", record_id, false ]
    when :priority
      ["#{Enumeration.table_name}.id = (?) AND #{IssueStatus.table_name}.is_closed = ?", record_id, false ]
    end
  end

end

# app/models/stuff_to_do.rb
class StuffToDo < ActiveRecord::Base
  def self.using_projects_as_items?
    use_setting == 'All' || use_setting  == 'Only Projects'
  end

  def self.using_issues_as_items?
    use_setting == 'All' || use_setting  == 'Only Issues'
  end
end

class StuffToDo < ActiveRecord::Base
  def self.using_projects_as_items?
    ['All', 'Only Projects'].include?(use_setting)
  end

  def self.using_issues_as_items?
    ['All', 'Only Issues'].include?(use_setting)
  end
end

# app/models/stuff_to_do.rb
class StuffToDo < ActiveRecord::Base
  USE = {
    'All' => '0',
    'Only Issues' => '1',
    'Only Projects' => '2'
  }

  def self.using_projects_as_items?
    using = USE.index(Setting.plugin_stuff_to_do_plugin['use_as_stuff_to_do'])
    using == 'All' || using  == 'Only Projects'
  end

  def self.using_issues_as_items?
    using = USE.index(Setting.plugin_stuff_to_do_plugin['use_as_stuff_to_do'])
    using == 'All' || using  == 'Only Issues'
  end
end

class StuffToDo < ActiveRecord::Base
  USE = {
    'All' => '0',
    'Only Issues' => '1',
    'Only Projects' => '2'
  }
  def self.using_projects_as_items?
    use_setting == 'All' || use_setting  == 'Only Projects'
  end

  def self.using_issues_as_items?
    use_setting == 'All' || use_setting  == 'Only Issues'
  end

  private

  def self.use_setting
    USE.index(Setting.plugin_stuff_to_do_plugin['use_as_stuff_to_do'])
  end
end

# app/controller/issues_controller.rb
class IssuesController < ApplicationController
 def index
    retrieve_query
    sort_init(@query.sort_criteria.empty? ? [['id', 'desc']] : @query.sort_criteria)
    sort_update({'id' => "#{Issue.table_name}.id"}.merge(@query.available_columns.inject({}) {|h, c| h[c.name.to_s] = c.sortable; h}))
    # ...
  end

  def changes
    retrieve_query
    sort_init 'id', 'desc'
    sort_update({'id' => "#{Issue.table_name}.id"}.merge(@query.available_columns.inject({}) {|h, c| h[c.name.to_s] = c.sortable; h}))
    # ...
  end

end

# app/models/query.rb
class Query < ActiveRecord::Base
  # ..
end

# app/controller/issues_controller.rb
class IssuesController < ApplicationController
 def index
    retrieve_query
    sort_init(@query.sort_criteria.empty? ? [['id', 'desc']] : @query.sort_criteria)
    sort_update(@query.sortable_columns)
    # ...
  end

  def changes
    retrieve_query
    sort_init 'id', 'desc'
    sort_update(@query.sortable_columns)
    # ...
  end
end

# app/models/query.rb
class Query < ActiveRecord::Base
  # Returns a Hash of columns and the key for sorting
  def sortable_columns
    {'id' => "#{Issue.table_name}.id"}.merge(available_columns.inject({}) {|h, column|
                                               h[column.name.to_s] = column.sortable
                                               h
                                             })
  end
end

# app/controller/users_controller.rb
class UsersController < ApplicationController
  def edit_membership
    @user = User.find(params[:id])
    @membership = params[:membership_id] ? Member.find(params[:membership_id]) : Member.new(:principal => @user)
    @membership.attributes = params[:membership]
    @membership.save if request.post?
    respond_to do |format|
       format.html { redirect_to :controller => 'users', :action => 'edit', :id => @user, :tab => 'memberships' }
       format.js { 
         render(:update) {|page| 
           page.replace_html "tab-content-memberships", :partial => 'users/memberships'
           page.visual_effect(:highlight, "member-#{@membership.id}")
         }
       }
     end
  end
end

# app/controller/groups_controller.rb
class GroupsController < ApplicationController
  def edit_membership
    @group = Group.find(params[:id])
    @membership = params[:membership_id] ? Member.find(params[:membership_id]) : Member.new(:principal => @group)
    @membership.attributes = params[:membership]
    @membership.save if request.post?
    respond_to do |format|
       format.html { redirect_to :controller => 'groups', :action => 'edit', :id => @group, :tab => 'memberships' }
       format.js { 
         render(:update) {|page| 
           page.replace_html "tab-content-memberships", :partial => 'groups/memberships'
           page.visual_effect(:highlight, "member-#{@membership.id}")
         }
       }
     end
  end
end

# app/models/member.rb
class Member < ActiveRecord::Base
  # ..
end

# app/controller/users_controller.rb
class UsersController < ApplicationController
  def edit_membership
    @user = User.find(params[:id])
    @membership = Member.edit_membership(params[:membership_id], params[:membership], @user)
    @membership.save if request.post?
    respond_to do |format|
       format.html { redirect_to :controller => 'users', :action => 'edit', :id => @user, :tab => 'memberships' }
       format.js { 
         render(:update) {|page| 
           page.replace_html "tab-content-memberships", :partial => 'users/memberships'
           page.visual_effect(:highlight, "member-#{@membership.id}")
         }
       }
     end
  end
end

# app/controller/groups_controller.rb
class GroupsController < ApplicationController
  def edit_membership
    @group = Group.find(params[:id])
    @membership = Member.edit_membership(params[:membership_id], params[:membership], @group)
    @membership.save if request.post?
    respond_to do |format|
       format.html { redirect_to :controller => 'groups', :action => 'edit', :id => @group, :tab => 'memberships' }
       format.js { 
         render(:update) {|page| 
           page.replace_html "tab-content-memberships", :partial => 'groups/memberships'
           page.visual_effect(:highlight, "member-#{@membership.id}")
         }
       }
     end
  end
end

# app/models/member.rb
class Member < ActiveRecord::Base
  # Find or initilize a Member with an id, attributes, and for a Principal
  def self.edit_membership(id, new_attributes, principal=nil)
    @membership = id.present? ? Member.find(id) : Member.new(:principal => principal)
    @membership.attributes = new_attributes
    @membership
  end
end

# app/controller/application_controller.rb
class ApplicationController < ActionController::Base
  # ...
end

# app/controller/documents_controller
class DocumentsController < ApplicationController
  before_filter :find_document, :except => [:index, :new]

  private

  def find_document
    @document = @object = Document.find(params[:id])
  rescue ActiveRecord::RecordNotFound
    render_404
  end
end

# app/controller/issue_categories_controller
class IssueCategoriesController < ApplicationController
  before_filter :find_category, :except => :new

  private

  def find_category
    @category = @object = IssueCategory.find(params[:id])
  rescue ActiveRecord::RecordNotFound
    render_404
  end 
end

# app/controller/application_controller.rb
class ApplicationController < ActionController::Base
  def find_model_object
    model = self.class.read_inheritable_attribute('model_object')
    if model
      @object = model.find(params[:id])
      self.instance_variable_set('@' + controller_name.singularize, @object) if @object
    end
  rescue ActiveRecord::RecordNotFound
    render_404
  end

  def self.model_object(model)
    write_inheritable_attribute('model_object', model)
  end
end

# app/controller/documents_controller
class DocumentsController < ApplicationController
  model_object Document
  before_filter :find_model_object, :except => [:index, :new]
end

# app/controller/issue_categories_controller
class IssueCategoriesController < ApplicationController
  model_object IssueCategory
  before_filter :find_model_object, :except => :new

  private

  # Wrap ApplicationController's find_model_object method to set
  # @category instead of just @issue_category
  def find_model_object
    super
    @category = @object
  end
end

# app/controller/issue_relations_controller.rb
class IssueRelationsController < ApplicationController
  before_filter :find_project, :authorize

  private

  def find_project
    @issue = Issue.find(params[:issue_id])
    @project = @issue.project
  rescue ActiveRecord::RecordNotFound
    render_404
  end
end

# app/controller/application_controller.rb
class ApplicationController < ActionController::Base
  # 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
  end
end

# app/controller/issue_relations_controller.rb
class IssueRelationsController < ApplicationController
  before_filter :find_issue, :find_project_from_association, :authorize

  private

  def find_issue
    @issue = @object = Issue.find(params[:issue_id])
  rescue ActiveRecord::RecordNotFound
    render_404
  end
end

# app/controller/issues_controller.rb
class IssuesController < ApplicationController
  def bulk_edit
    if request.post?
      # ...
      if unsaved_issue_ids.empty?
        flash[:notice] = l(:notice_successful_update) unless @issues.empty?
      else
        flash[:error] = l(:notice_failed_to_save_issues, :count => unsaved_issue_ids.size,
                                                         :total => @issues.size,
                                                         :ids => '#' + unsaved_issue_ids.join(', #'))
      end
      redirect_back_or_default({:controller => 'issues', :action => 'index', :project_id => @project})
      return
    end
    @available_statuses = Workflow.available_statuses(@project)
    @custom_fields = @project.all_issue_custom_fields
  end

  def move
    # ... inside of an if statement

      if unsaved_issue_ids.empty?
        flash[:notice] = l(:notice_successful_update) unless @issues.empty?
      else
        flash[:error] = l(:notice_failed_to_save_issues, :count => unsaved_issue_ids.size,
                                                         :total => @issues.size,
                                                         :ids => '#' + unsaved_issue_ids.join(', #'))
      end

   # ...
  end

end

# app/controller/issues_controller.rb
class IssuesController < ApplicationController
  def bulk_edit
    if request.post?
      # ...
      set_flash_from_bulk_issue_save(@issues, unsaved_issue_ids)
      redirect_back_or_default({:controller => 'issues', :action => 'index', :project_id => @project})
      return
    end
    @available_statuses = Workflow.available_statuses(@project)
    @custom_fields = @project.all_issue_custom_fields
  end

  def move
    # ... inside of an if statement

      set_flash_from_bulk_issue_save(@issues, unsaved_issue_ids)

   # ...
  end
  
  def set_flash_from_bulk_issue_save(issues, unsaved_issue_ids)
    if unsaved_issue_ids.empty?
      flash[:notice] = l(:notice_successful_update) unless issues.empty?
    else
      flash[:error] = l(:notice_failed_to_save_issues,
                        :count => unsaved_issue_ids.size,
                        :total => issues.size,
                        :ids => '#' + unsaved_issue_ids.join(', #'))
    end
  end

end