stuff_to_do_plugin 0.4.0

data/VERSION

@@ -0,0 +1 @@
+0.4.0

data/app/controllers/stuff_to_do_controller.rb

@@ -0,0 +1,161 @@
+class StuffToDoController < ApplicationController
+  unloadable
+
+  before_filter :get_user
+  before_filter :get_time_grid, :only => [:index, :time_grid]
+  before_filter :require_admin, :only => :available_issues
+  helper :stuff_to_do
+  helper :timelog
+  
+  def index
+    @doing_now = StuffToDo.doing_now(@user)
+    @recommended = StuffToDo.recommended(@user)
+    @available = StuffToDo.available(@user, default_filters )
+    
+    @users = User.active
+    @filters = filters_for_view
+  end
+  
+  def reorder
+    StuffToDo.reorder_list(@user, params[:stuff])
+    @doing_now = StuffToDo.doing_now(@user)
+    @recommended = StuffToDo.recommended(@user)
+    @available = StuffToDo.available(@user, get_filters )
+
+    respond_to do |format|
+      format.html { redirect_to :action => 'index'}
+      format.js { render :partial => 'panes', :layout => false}
+    end
+  end
+  
+  def available_issues
+    @available = StuffToDo.available(@user, get_filters)
+
+    respond_to do |format|
+      format.html { redirect_to :action => 'index'}
+      format.js { render :partial => 'right_panes', :layout => false}
+    end
+  end
+  
+  def time_grid
+    respond_to do |format|
+      format.html { redirect_to :action => 'index'}
+      format.js { render :partial => 'time_grid', :layout => false}
+    end
+  end
+
+  def add_to_time_grid
+    issue = Issue.visible.find_by_id(params[:issue_id])
+    # Issue exists and isn't already in user's list
+    if issue && !User.current.time_grid_issues.exists?(issue)
+      User.current.time_grid_issues << issue
+    end
+    get_time_grid
+    time_grid
+  end
+
+  def remove_from_time_grid
+    issue = User.current.time_grid_issues.visible.find_by_id(params[:issue_id])
+    User.current.time_grid_issues.delete(issue) if issue
+    get_time_grid
+    time_grid
+  end
+
+  def save_time_entry
+    @time_entry = TimeEntry.new
+    @time_entry.user = User.current
+    if params[:time_entry] &&  params[:time_entry].first
+      @time_entry.attributes = params[:time_entry].first
+    end
+    @time_entry.project = @time_entry.issue.project if @time_entry.issue
+    respond_to do |format|
+      if save_time_entry_from_time_grid(@time_entry)
+        flash.now[:time_grid_notice] = l(:notice_successful_update)
+        get_time_grid # after saving in order to get the updated data
+        
+        format.js { time_grid }
+      else
+        format.js { render :text => @time_entry.errors.full_messages.join(', '), :status => 403, :layout => false }
+      end
+    end
+  end
+
+  private
+  
+  def get_user
+    render_403 unless User.current.logged?
+    
+    if params[:user_id] && params[:user_id] != User.current.id.to_s
+      if User.current.admin?
+        @user = User.find(params[:user_id])
+      else
+        render_403
+      end
+    else
+      @user = User.current  
+    end
+  end
+  
+  def filters_for_view
+    StuffToDoFilter.new
+  end
+
+  def get_filters
+    return default_filters unless params[:filter]
+
+    id = params[:filter].split('-')[-1]
+
+    if params[:filter].match(/users/)
+      return User.find_by_id(id)
+    elsif params[:filter].match(/priorities/)
+      return Enumeration.find_by_id(id)
+    elsif params[:filter].match(/statuses/)
+      return IssueStatus.find_by_id(id)
+    elsif params[:filter].match(/projects/)
+      return Project.new
+    else
+      return nil
+    end
+  end
+
+  def default_filters
+    if StuffToDo.using_issues_as_items?
+      return @user
+    elsif StuffToDo.using_projects_as_items?
+      return Project.new
+    else
+      # Edge case
+      return { }
+    end
+  end
+
+  def get_time_grid
+    @date = parse_date_from_params
+    @calendar = Redmine::Helpers::Calendar.new(@date, current_language, :week)
+    @issues = User.current.time_grid_issues.visible.all(:order => "#{Issue.table_name}.id ASC")
+    @time_entry = TimeEntry.new
+  end
+
+  # Wrap saving the TimeEntry because TimeEntries from the time grid should
+  # require comments.
+  def save_time_entry_from_time_grid(time_entry)
+    time_entry.valid? # Run normal validations
+
+    # Additional validations
+    if time_entry.comments.blank?
+      time_entry.errors.add(:comments, :empty)
+    end
+
+    if time_entry.errors.empty? && User.current.allowed_to?(:log_time, time_entry.project)
+      return time_entry.save
+    else
+      return false
+    end
+  end
+
+  def parse_date_from_params
+    date = Date.parse(params[:date]) if params[:date]
+    date ||= Date.civil(params[:year].to_i, params[:month].to_i, params[:day].to_i) if params[:year] && params[:month] && params[:day]
+    date ||= Date.today
+  end
+end

data/app/helpers/stuff_to_do_helper.rb

@@ -0,0 +1,88 @@
+module StuffToDoHelper
+  def progress_bar_sum(collection, field, opts)
+    issues = remove_non_issues(collection)
+    
+    total = issues.inject(0) {|sum, n| sum + n.read_attribute(field) }
+    divisor = issues.length
+    return if divisor.nil? || divisor == 0
+
+    progress_bar(total / divisor, opts)
+  end
+  
+  def total_estimates(issues)
+    remove_non_issues(issues).collect(&:estimated_hours).compact.sum
+  end
+  
+  def filter_options(filters, selected = nil)
+    html = options_for_select([[l(:stuff_to_do_label_filter_by), '']]) # Blank
+
+    filters.each do |filter_group, options|
+      next unless [:users, :priorities, :statuses, :projects].include?(filter_group)
+      if filter_group == :projects
+        # Projects only needs a single item
+        html << content_tag(:option,
+                            filter_group.to_s.capitalize,
+                            :value => 'projects',
+                            :style => 'font-weight: bold')
+      else
+        html << content_tag(:optgroup,
+                            options_for_select(options.collect { |item| [item.to_s, filter_group.to_s + '-' + item.id.to_s]}, selected),
+                            :label => filter_group.to_s.capitalize )
+      end
+    end
+    
+    return html
+  end
+
+  # Returns the stuff for a collection of StuffToDo items, removing anything
+  # that have been deleted.
+  def stuff_for(stuff_to_do_items)
+    return stuff_to_do_items.collect(&:stuff).compact
+  end
+
+  # Returns the issues for a collection of StuffToDo items, removing anything
+  # that have been deleted or isn't an Issue
+  def issues_for(stuff_to_do_items)
+    return remove_non_issues(stuff_to_do_items.collect(&:stuff).compact)
+  end
+
+  def remove_non_issues(stuff_to_do_items)
+    stuff_to_do_items.reject {|item| item.class != Issue }
+  end
+
+  def total_hours_for_user_on_day(issue, user, date)
+    total = issue.time_entries.inject(0.0) {|sum, time_entry|
+      if time_entry.user_id == user.id && time_entry.spent_on == date
+        sum += time_entry.hours
+      end
+      sum
+    }
+
+    total != 0.0 ? total : nil
+  end
+
+  def total_hours_for_issue_for_user(issue, user)
+    total = issue.time_entries.inject(0.0) {|sum, time_entry|
+      if time_entry.user_id == user.id
+        sum += time_entry.hours
+      end
+      sum
+    }
+    total
+  end
+
+  def total_hours_for_date(issues, user, date)
+    issues.collect {|issue| total_hours_for_user_on_day(issue, user, date)}.compact.sum
+  end
+
+  def total_hours_for_user(issues, user)
+    issues.collect {|issue| total_hours_for_issue_for_user(issue, user)}.compact.sum
+  end
+
+  # Redmine 0.8.x compatibility
+  def l_hours(hours)
+    hours = hours.to_f
+    l((hours < 2.0 ? :label_f_hour : :label_f_hour_plural), ("%.2f" % hours.to_f))
+  end unless Object.method_defined?('l_hours')
+
+end

data/app/models/stuff_to_do.rb

@@ -0,0 +1,208 @@
+# StuffToDo relates a user to another object at a specific postition
+# in a list.
+#
+# Supported objects:
+# * Issue
+# * Project
+class StuffToDo < ActiveRecord::Base
+  USE = {
+    'All' => '0',
+    'Only Issues' => '1',
+    'Only Projects' => '2'
+  }
+
+  belongs_to :stuff, :polymorphic => true
+  belongs_to :user
+  acts_as_list :scope => :user
+  
+  named_scope :doing_now, lambda { |user|
+    {
+      :conditions => { :user_id => user.id },
+      :limit => 5,
+      :order => 'position ASC'
+    }
+  }
+
+  # TODO: Rails bug
+  #
+  # ActiveRecord ignores :offset if :limit isn't added also.  But since we 
+  # want all the records, we need to provide a limit that will include everything
+  #
+  # http://dev.rubyonrails.org/ticket/7257
+  #
+  named_scope :recommended, lambda { |user|
+    {
+      :conditions => { :user_id => user.id },
+      :limit => self.count,
+      :offset => 5,
+      :order => 'position ASC'
+    }
+  }
+  
+  # Filters the issues that are available to be added for a user.
+  #
+  # A filter can be a record:
+  #
+  # * User - issues are assigned to this user
+  # * IssueStatus - issues with this status
+  # * IssuePriority - issues with this priority
+  #
+  def self.available(user, filter=nil)
+    return [] if filter.blank?
+
+    if filter.is_a?(Project)
+      potential_stuff_to_do = active_and_visible_projects.sort
+    else
+      potential_stuff_to_do = Issue.find(:all,
+                                         :include => [:status, :priority, :project],
+                                         :conditions => conditions_for_available(filter),
+                                         :order => "#{Issue.table_name}.created_on DESC")
+    end
+
+    stuff_to_do = StuffToDo.find(:all, :conditions => { :user_id => user.id }).collect(&:stuff)
+    
+    return potential_stuff_to_do - stuff_to_do
+  end
+
+  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
+
+  # Callback used to destroy all StuffToDos when an object is removed and
+  # send an email if a user is below the What's Recommend threshold
+  def self.remove_associations_to(associated_object)
+    user_ids = []
+    associated_object.stuff_to_dos.each do |stuff_to_do|
+      user_ids << stuff_to_do.user_id if stuff_to_do.user_id
+      stuff_to_do.destroy
+    end
+
+    # Deliver an email for each user who is below the threshold
+    user_ids.uniq.each do |user_id|
+      count = self.count(:conditions => { :user_id => user_id})
+      threshold = Setting.plugin_stuff_to_do_plugin['threshold']
+
+      if threshold && threshold.to_i >= count
+        user = User.find_by_id(user_id)
+        StuffToDoMailer.deliver_recommended_below_threshold(user, count)
+      end
+    end
+    
+    return true
+  end
+  
+  # Destroys all +NextIssues+ on an +issue+ that are not the assigned to user
+  def self.remove_stale_assignments(issue)
+    if issue.assigned_to_id.nil?
+      self.destroy_all(['stuff_id = (?)', issue.id])
+    else
+      self.destroy_all(['stuff_id = (?) AND user_id NOT IN (?)',
+                             issue.id,
+                             issue.assigned_to_id])
+    end
+  end
+  
+  # Reorders the list of StuffToDo items for +user+ to be in the order of
+  # +ids+.  New StuffToDos will be created if needed and old
+  # StuffToDos will be removed if they are unassigned.
+  #
+  # Project based ids need to be prefixed with +project+
+  def self.reorder_list(user, ids)
+    ids ||= []
+    id_position_mapping = ids.to_hash
+
+    issue_ids = {}
+    project_ids = {}
+
+    id_position_mapping.each do |key,value|
+      if value.match(/project/i)
+        project_ids[key] = value.sub(/project/i,'').to_i
+      else
+        issue_ids[key] = value.to_i
+      end
+    end
+
+    reorder_issues(user, issue_ids)
+    reorder_projects(user, project_ids)
+  end
+
+  private
+
+  def self.reorder_issues(user, issue_ids)
+    reorder_items('Issue', user, issue_ids)
+  end
+
+  def self.reorder_projects(user, project_ids)
+    reorder_items('Project', user, project_ids)
+  end
+
+  def self.reorder_items(type, user, ids)
+    list = self.find_all_by_user_id_and_stuff_type(user.id, type)
+    stuff_to_dos_found = list.collect { |std| std.stuff_id.to_i }
+
+    remove_missing_records(user, stuff_to_dos_found, ids.values)
+
+    ids.each do |position, id|
+      if existing_list_position = stuff_to_dos_found.index(id.to_i)
+        position = position + 1  # acts_as_list is 1 based
+        stuff_to_do = list[existing_list_position]
+        stuff_to_do.insert_at(position)
+      else
+        # Not found in list, so create a new StuffToDo item
+        stuff_to_do = self.new
+        stuff_to_do.stuff_id = id
+        stuff_to_do.stuff_type = type
+        stuff_to_do.user_id = user.id
+
+        stuff_to_do.save # TODO: Check return
+        
+        # Have to resave next_issue since acts_as_list automatically moves it
+        # to the bottom on create
+        stuff_to_do.insert_at(position + 1)  # acts_as_list is 1 based
+      end
+    end
+  
+  end
+
+  # Destroys saved records that are +ids_found_in_database+ but are
+  # not in +ids_to_use+
+  def self.remove_missing_records(user, ids_found_in_database, ids_to_use)
+    removed = ids_found_in_database - ids_to_use
+    removed.each do |id|
+      removed_stuff_to_do = self.find_by_user_id_and_stuff_id(user.id, id)
+      removed_stuff_to_do.destroy
+    end
+  end
+
+  # Redmine 0.8.x compatibility method.
+  def self.active_and_visible_projects
+    if ::Project.respond_to?(:active) && ::Project.respond_to?(:visible)
+      return ::Project.active.visible
+    else
+      return ::Project.find(:all, :conditions => Project.visible_by)
+    end
+  end
+
+  def self.use_setting
+    USE.index(Setting.plugin_stuff_to_do_plugin['use_as_stuff_to_do'])
+  end
+
+  def self.conditions_for_available(filter_by)
+    conditions_builder = ARCondition.new(["#{IssueStatus.table_name}.is_closed = ?", false ])
+    conditions_builder.add(["#{Project.table_name}.status = ?", Project::STATUS_ACTIVE])
+
+    case 
+    when filter_by.is_a?(User)
+      conditions_builder.add(["assigned_to_id = ?", filter_by.id])
+    when filter_by.is_a?(IssueStatus), filter_by.is_a?(Enumeration)
+      table_name = filter_by.class.table_name
+      conditions_builder.add(["#{table_name}.id = (?)", filter_by.id])
+    end
+
+    conditions_builder.conditions
+  end
+end