backlog 0.37.2 → 0.41.4

data/app/models/project.rb

@@ -1,49 +0,0 @@
-class Project < ActiveRecord::Base
-  validates_presence_of :name
-  validates_length_of :name, :allow_nil => false, :maximum => 64
-  validates_uniqueness_of :name
-  validates_inclusion_of :track_todo, :in => [true, false], :allow_nil => true, :message => I18n.translate('activerecord.errors.messages')[:blank]
-  validates_inclusion_of :enable_subtasks, :in => [true, false], :allow_nil => false, :message => I18n.translate('activerecord.errors.messages')[:blank]
-  validates_inclusion_of :enable_customer, :in => [true, false], :allow_nil => true, :message => I18n.translate('activerecord.errors.messages')[:blank]
-  validates_inclusion_of :enable_users, :in => [true, false], :allow_nil => true, :message => I18n.translate('activerecord.errors.messages')[:blank]
-
-  belongs_to :customer
-  has_many :tasks, :order => 'period_id, position', :dependent => :destroy
-  has_many :unplanned_tasks, :class_name => 'Task', :conditions => 'period_id IS NULL', :order => 'position'
-  has_many :works, :dependent => :destroy
-  has_and_belongs_to_many :work_lock_subscribers, :class_name => 'User', :join_table => "work_lock_subscriptions", :foreign_key => "project_id", :association_foreign_key => 'subscriber_user_id'
-
-  validates_inclusion_of :track_times, :in => [true, false], :message => I18n.translate('activerecord.errors.messages')[:blank]
-
-  def active_tasks
-    tasks.find(:all, :conditions => "finished_at IS NULL", :order => "position")
-  end
-
-  def recent_tasks
-    Task.find(:all, :conditions => "period_id = #{periods.first.id} AND (position IS NOT NULL OR finished_at >= '#{1.week.ago.iso8601}')", :order => "position, finished_at")
-  end
-
-  def tasks_with_children
-    tasks.map {|t| t.self_with_children}.flatten
-  end
-  
-  def first_active_period
-    t = active_tasks
-    periods = t.map {|t| t.period}.compact.uniq
-    periods = periods.select {|p| p.active?}
-    periods.sort_by {|p| p.end_on}.first
-  end
-  
-  def enable_invoicing?
-    true
-  end
-
-  def track_done?
-    true
-  end
-  
-  def total_hours
-    works.inject(BigDecimal('0')) {|total, work| total + work.hours}
-  end
-  
-end

data/app/models/public_holiday.rb

@@ -1,13 +0,0 @@
-class PublicHoliday < ActiveRecord::Base
-  # Return an array of either a public holiday or nil for each day of the given week.
-  def self.find_by_week(year, week)
-    first_date = Date.commercial(year, week, 1)
-    last_date = first_date + 6
-    results = self.find(:all, :conditions => ['"on" BETWEEN ? AND ?', first_date, last_date], :order => '"on"')
-    (0..6).each do |day|
-      results.insert(day, nil) if results[day] && results[day].on > first_date + day
-    end
-    results
-  end
-  
-end

data/app/models/report_filter.rb

@@ -1,29 +0,0 @@
-class ReportFilter
-  attr_accessor :title
-  attr_reader :start_on
-  attr_reader :end_on
-  attr_reader :page_size
-  
-  def initialize(attributes)
-    date = Date.today - 5
-    @start_on = Date.civil(date.year, date.month, 01)
-    @end_on   = Date.civil(date.year, date.month, -1)
-    @page_size = 1000
-
-    if attributes
-      attributes = attributes.clone
-      
-      start_on_param = attributes.delete(:start_on)
-      @start_on = Date.parse(start_on_param) if start_on_param && start_on_param.size > 0
-      
-      end_on_param = attributes.delete(:end_on)
-      @end_on = Date.parse(end_on_param) if end_on_param && end_on_param.size > 0
-      
-      page_size_param = attributes.delete(:page_size)
-      @page_size = page_size_param.to_i if page_size_param.to_i > 0
-      
-      raise "Unknown parameters: #{attributes.inspect}" unless attributes.empty?
-    end
-  end
-  
-end

data/app/models/search_result.rb

@@ -1,8 +0,0 @@
-class SearchResult
-  attr_reader :title, :options
-  
-  def initialize(title, options)
-    @title = title
-    @options = options
-  end
-end

data/app/models/sidebar.rb

@@ -1,41 +0,0 @@
-require 'action_view/helpers/url_helper'
-
-class Sidebar
-  include Rails.application.routes.url_helpers
-  include ActionView::Helpers::TagHelper
-  include ERB::Util
-  
-  def initialize(controller)
-    @controller = controller
-  end
-
-  def blocks(period)
-    @period = period
-    # TODO (uwe): This does not scale!
-    #periods = Period.find(:all).select {|period| period.active_or_future?(true) && period.party.includes?(user)}
-    periods = Period.find_active_or_future(true)
-    
-    blocks = periods.sort_by {|p| p.required_speed}.reverse.map do |period|
-      content = @controller.render_to_string :partial => '/periods/sidebar_block',
-          :locals => {:period => period}
-        
-      { :id => period.id,
-        :title => "#{period.party.name}##{period.position} (#{'%0.1f' % period.required_speed})",
-        :options => {:controller => 'periods', :action => :show, :id => period},
-        :content => content
-      }
-    end
-    started_tasks = Task.find_started
-    if not started_tasks.empty?
-      links = started_tasks.map do |task|
-      "<li><a href=\"#{url_for(:host => @controller.request.host_with_port, :controller => 'tasks', :action => 'list_started', :id => task.id)}\">#{task.description}</a></li>"
-      end
-      blocks.unshift({ :title   => @controller.l(:started_tasks),
-        :options => {:controller => 'tasks', :action => :list_started},
-        :content => "<ul>#{links}"
-      })
-    end
-    blocks
-  end
-    
-end

data/app/models/task.rb

@@ -1,425 +0,0 @@
-require 'time_extras'
-
-class Task < ActiveRecord::Base
-  extend UserSystem
-  include UserSystem
-  
-  COMPLETED = 'COMPLETED'
-  POSTPONED = 'POSTPONED'
-  MOVED = 'MOVED'
-  ABORTED     = 'ABORTED'
-  
-  belongs_to :project
-  belongs_to :period
-  belongs_to :ancestor_task, :class_name => 'Task', :foreign_key => 'previous_task_id' 
-  belongs_to :customer
-  has_many :descendant_tasks, :class_name => 'Task', :foreign_key => 'previous_task_id', :dependent => :destroy
-  has_many :estimates, :order => 'created_at', :dependent => :destroy
-  has_many :works, :order => 'completed_at', :dependent => :destroy
-  has_many :task_files, :dependent => :destroy
-  has_and_belongs_to_many :users
-  belongs_to :creator, :class_name => 'User', :foreign_key => 'created_by'
-  belongs_to :updater, :class_name => 'User', :foreign_key => 'updated_by'
-  
-  acts_as_list :scope => '#{parent_id ? "parent_id = #{parent_id}" : period_id ? "period_id = #{period_id}" : "period_id IS NULL AND parent_id IS NULL AND project_id = #{project_id}"} AND finished_at IS NULL'
-  acts_as_tree :order => 'position'
-  
-  validates_presence_of :project_id, :if => Proc.new { |task| task.parent_id.nil? }
-  validates_presence_of :parent_id, :if => Proc.new { |task| task.project_id.nil? }
-  validates_presence_of :position, :on => :update, :if => Proc.new { |task| task.finished_at.nil? }
-  validates_presence_of :finished_at, :on => :update, :if => Proc.new { |task| task.position.nil? }
-  validates_presence_of :resolution, :if => :finished_at
-  validates_presence_of :description, :if => :project_id
-  
-  validates_size_of :description, :maximum => 80, :if => :description
-  
-  #validates_uniqueness_of :description, :scope => :project_id, :if => Proc.new {|task| task.project_id && task.previous_task_id.nil?}
-  validates_uniqueness_of :description, :scope => :period_id, :if => :period_id
-  validates_uniqueness_of :position, :scope => :parent_id, :if => :parent_id, :allow_nil => true
-  validates_uniqueness_of :position, :scope => :period_id, :if => :period_id, :allow_nil => true
-  validates_uniqueness_of :position, :scope => [:period_id, :parent_id, :project_id], :if => Proc.new {|task| task.period_id.nil? && task.parent_id.nil?}, :allow_nil => true
-  
-  before_create {|record| record.created_by = current_user.id}
-  before_save {|record| record.updated_by = current_user.id}
-  
-  validate do |r|
-    if r.parent_id && (r.period_id || r.project_id)
-      r.errors.add :parent_id, "A subtask may have neither period nor project set."
-    end
-    if r.new_record? && r.period && r.period.passed?
-      r.errors.add :period_id, "You may not add a task to a past period."
-    end
-  end
-  
-  def self.find_open
-    find(:all, :conditions => 'finished_at IS NULL', :order => 'description')
-  end
-  
-  def self.find_started
-    if current_user
-      user_clause = " OR user_id = #{current_user.id}"
-    end
-    conditions = "start_time IS NOT NULL AND completed_at IS NULL AND (user_id IS NULL#{user_clause})"
-    Work.find(:all, :conditions => conditions).map {|work| work.task}.compact.sort_by do |t|
-      [t.root_task.project.name, t.root_task.period ? t.root_task.period.end_on : 0, t.position || 0]
-    end
-  end
-  
-  def self.recent_conditions
-    return "finished_at >= '#{1.week.ago.iso8601}'"
-  end
-
-  def self.find_descendant(period_id, ancestor_task_id)
-    candidate_tasks = Task.find :all, 
-        :conditions => ["id = ? OR previous_task_id = ?", ancestor_task_id, ancestor_task_id]
-    candidate_tasks = candidate_tasks.select {|t| t.root_task.period_id == period_id}
-    logger.error "Multiple descendants in period: #{period_id} #{ancestor_task_id}" if candidate_tasks.size > 1
-    candidate_tasks[0]
-  end
-  
-  def self_with_children
-    [self] << children.map {|t| t.self_with_children}.flatten
-  end
-  
-  def todo
-    estimates.last ? estimates.last.todo : initial_estimate
-  end
-  
-  def estimate(new_todo)
-    return unless new_todo && new_todo != ''
-    new_todo = new_todo.to_i
-    if new_todo == 0
-      finish(Task::COMPLETED, false)
-    end
-    previous_estimate = estimates.last
-    new_estimate = Estimate.new
-    if previous_estimate
-      return if new_todo == previous_estimate.todo
-    else
-      return if new_todo == initial_estimate
-    end
-    now = Time.now
-    if previous_estimate && (now < previous_estimate.created_at || now.strftime('%Y-%m-%DT%H:%M:%S') == previous_estimate.created_at.strftime('%Y-%m-%DT%H:%M:%S'))
-      previous_estimate.todo = new_todo
-      previous_estimate.user = current_user
-      previous_estimate.save!
-    else
-      new_estimate.task_id = self.id
-      new_estimate.todo = new_todo
-      new_estimate.created_at = now
-      new_estimate.user = current_user
-      new_estimate.save!
-      estimates << new_estimate
-    end
-  end
-  
-  def done
-    nil
-  end
-  
-  def done=(hours_done)
-    return unless hours_done && hours_done != '' && BigDecimal(hours_done) != 0
-    return if end_work(hours_done)
-    new_work = Work.new
-    new_work.hours = hours_done
-    new_work.task_id = self.id
-    new_work.completed_at = DateTime.now
-    new_work.save!
-    works << new_work
-  end
-  
-  def total_done
-    total = BigDecimal('0')
-    works.each {|work| total += work.hours}
-    total
-  end
-  
-  def open
-    if finished_at
-      self.finished_at = nil
-      self.resolution = nil
-      self.position = nil
-      insert_at 1
-      estimate(initial_estimate)
-      parent.open if parent
-    end
-  end
-  
-  def reopen
-    if period && period.passed?
-      raise "You cannot reopen a task in a period that is passed."
-    else
-      open
-      save!
-      children.each {|child_task| child_task.reopen}
-    end
-    self
-  end
-  
-  def move_to_period(new_period)
-    raise "Cannot move finished tasks" unless active?
-    return self if new_period == period
-    
-    self.remove_from_list
-    self.position = nil
-    
-    if self.period
-      old_todo = self.todo
-      if parent
-        parent.move_to_period new_period
-      end
-      if leaf?
-        self.finish((new_period.nil? || (new_period.party == self.period.party)) ? Task::POSTPONED : Task::MOVED, true)
-      end
-      existing_task = Task.find_descendant(new_period && new_period.id, ancestor_id)
-      if existing_task ||= Task.find_by_period_id_and_previous_task_id(new_period && new_period.id, ancestor_id)
-        raise "mismatch" unless existing_task.project == root_task.project
-        raise "Mismatch" unless existing_task.period == new_period
-        existing_task.open
-        existing_task.previous_task_id = self.previous_task_id || self.id
-        existing_task.description = self.description
-        existing_task.users = self.users
-        existing_task.save!
-        existing_task.estimate(old_todo)
-        return existing_task
-      else
-        new_task = Task.new
-        new_task.previous_task_id = ancestor_id
-        if parent
-          new_parent = Task.find_descendant(new_period.id, parent.ancestor_id)
-          new_task.parent = new_parent
-        else
-          new_task.project = root_task.project
-          new_task.period = new_period
-        end
-        new_task.description = self.description
-        new_task.initial_estimate = self.initial_estimate
-        new_task.position = nil
-        new_task.users = self.users
-        new_task.save!
-        new_task.insert_at 1
-        new_task.estimate(old_todo)
-        return new_task
-      end
-    else
-      self.period_id = new_period && new_period.id
-      self.period = new_period
-      self.insert_at(1)
-      self.position = 1
-      self.move_to_bottom
-      self.save!
-      return self
-    end
-  end
-  
-  def grab
-    self.users << current_user
-  end
-  
-  def release
-    self.users.delete current_user
-  end
-  
-  def finish(resolution, save_work)
-    unless finished_at || work_started?
-      self.finished_at = Time.now
-      self.resolution = resolution
-      remove_from_list
-      self.position = nil
-      save!
-      estimate(0) if save_work
-      parent.check_finished(self.finished_at, resolution, save_work) if parent
-    end
-  end
-  
-  def check_finished(subtask_finsihed_at, resolution, save_work)
-    return if self.finished_at
-    children.each do |child_task|
-      return if child_task.active?
-    end
-    finish(resolution, save_work)
-  end
-  
-  def active?
-    finished_at.nil? || work_started? || active_children?
-  end
-  
-  def active_children?
-    children.detect {|child| child.active?}
-  end
-  
-  def finished?
-    completed?
-  end
-  
-  def completed?
-    finished_at || completed_children?
-  end
-  
-  def completed_children?
-    children.detect {|child| child.completed?}
-  end
-  
-  def loggable?
-    active? && leaf?
-  end
-  
-  def leaf?
-    children.size == 0
-  end
-  
-  def root?
-    parent.nil?
-  end
-  
-  def root_task
-    root_task = self 
-    root_task = root_task.parent while root_task.parent
-    root_task
-  end
-  
-  def invoicing?
-    root_task.project.enable_invoicing?
-  end
-  
-  def track_done?
-    project.track_done?
-  end
-
-  def track_times?
-    project.try :track_times?
-  end
-  
-  def track_todo?
-    root_task.project.track_todo?
-  end
-  
-  def enable_subtasks?
-    root_task.project.enable_subtasks?
-  end
-  
-  def enable_users?
-    root_task.project.enable_users?
-  end
-  
-  def enable_customer?
-    root_task.project.enable_customer?
-  end
-  
-  def enable_invoicing?
-    root_task.project.enable_invoicing?
-  end
-  
-  alias_method :old_period, :period
-  def period
-    old_period || root_task.old_period
-  end
-  
-  alias_method :old_project, :project
-  def project
-    old_project || root_task.old_project
-  end
-  
-  def depth
-    root_task = self 
-    depth = 0
-    while !root_task.root?
-      root_task = root_task.parent
-      depth += 1
-    end
-    depth
-  end
-  
-  def estimate_data(date, actual=false)
-    if children.empty?
-      return 0 if actual && (resolution == ABORTED || resolution == POSTPONED)
-      return 0 if finished_at && (date >= finished_at.to_date)
-      estimate = Estimate.find(:first, :conditions => "task_id = #{id} AND created_at < '#{(date+1).to_s}'", :order => 'created_at DESC,id DESC')
-      if estimate
-        estimate.todo
-      elsif actual || created_at < (date+1).to_time
-        initial_estimate
-      else
-        0
-      end
-    else
-      total = BigDecimal('0')
-      children.each {|child_task| total += child_task.estimate_data(date, actual)}
-      total
-    end
-  end
-  
-  def work_data(date)
-    return 0 if resolution == ABORTED
-    relevant_works = Work.find(:all, :conditions => "task_id = #{id} AND completed_at < '#{(date+1).to_s}'")
-    total = BigDecimal('0')
-    relevant_works.each do |work|
-      total += work.hours
-    end
-    total
-  end
-  
-  def start_work
-    return if work_started?
-    open
-    grab if current_user
-    new_work = works.new
-    
-    # TODO (uwe): Only needed for rails 1.2.x branch.  Remove when moving to 1.3 or 2.0.
-    new_work.task = self
-    
-    new_work.started_on = Time.previous_quarter.to_date
-    new_work.start_time = Time.previous_quarter.time_of_day
-    if current_user
-      last_work = current_user.works.select {|w| w.completed_at}.last
-    else
-      last_work = Work.find(:first, :conditions => 'completed_at IS NOT NULL', :order => 'completed_at DESC')
-    end
-    if last_work && last_work.completed_at > new_work.started_on.at(new_work.start_time)
-      new_work.started_at = last_work.completed_at
-    end
-    
-    new_work.user = current_user
-    new_work.project_id = project.id
-    new_work.save!
-    works << new_work
-  end
-  
-  def works_with_children
-    works << children.map {|t| t.works_with_children}.flatten
-  end
-  
-  def abort
-    finish(Task::ABORTED, false)
-  end
-  
-  def work_started?
-    !started_work.nil? 
-  end
-  
-  def started_work
-    started_works = works.select {|work| work.start_time && work.completed_at.nil?}
-    if current_user
-      started_by_user = started_works.select {|work| work.user == current_user}.last
-      return started_by_user if started_by_user
-    end
-    started_works.select {|work| work.user.nil?}.last
-  end
-  
-  def description_with_id
-    "##{id}: #{description}"
-  end
-  
-  def description_with_parents
-    if parent.nil?
-      "#{project.name}: #{description}"
-    else
-      "#{parent.description_with_parents} - #{description}"
-    end
-  end
-
-  def ancestor_id
-    previous_task_id || id
-  end
-  
-end