backlog 0.36.2 → 0.37.1

data/app/helpers/periods_helper.rb

@@ -21,7 +21,7 @@ module PeriodsHelper
   end
   
   def add_active_task(page)
-    page.insert_html(:top, "active_tasks_#{@task.period.id}", render(:partial => "/tasks/task", :locals => { :task => @task, :i => 1, :active => true, :highlight_task => false, :update => :spotlight, :hidden => true, :show_backlog => false }))
+    page.insert_html(:top, "active_tasks_#{@task.period.id}", render(:partial => "/tasks/task", :locals => { :task => @task, :i => 1, :active => true, :highlight_task => false, :update => :spotlight, :hidden => true, :show_project => false }))
     
     page[:no_tasks_message].hide
     
@@ -43,9 +43,9 @@ module PeriodsHelper
       period_tag_id = "completed_period_#{@task.period_id}"
       page.insert_html :top, "completed_tasks", %Q{<div id="#{period_tag_id}" />}
       page.insert_html :top, period_tag_id, %Q{<ul id="#{list_tag_id}" class="task_list"/>}
-      page.insert_html :top, period_tag_id, :partial => '/tasks/fields_header', :locals => {:backlog => @task.backlog, :active => false, :work_done => work_done}
+      page.insert_html :top, period_tag_id, :partial => '/tasks/fields_header', :locals => {:project => @task.project, :active => false, :work_done => work_done}
     end
-    page.insert_html :top, list_tag_id, :partial => '/tasks/task', :locals => {:active => false, :hidden => true, :highlight_task => false, :show_backlog => true}
+    page.insert_html :top, list_tag_id, :partial => '/tasks/task', :locals => {:active => false, :hidden => true, :highlight_task => false, :show_project => true}
     page.visual_effect :appear, "task_#{@task.id}"
     
   end

data/app/helpers/{backlogs_helper.rb → projects_helper.rb}

@@ -1,4 +1,4 @@
-module BacklogsHelper
+module ProjectsHelper
   def remove_active_task(page)
     page.visual_effect :blind_up, "task_#{@task.id}"
     last_in_period = @tasks.find {|t| t.period_id == @task.period_id}.nil?
@@ -23,11 +23,11 @@ module BacklogsHelper
       period_tag_id = "completed_period_#{@task.period_id}"
       page.insert_html :top, :completed_tasks, "<div id=\"#{period_tag_id}\ />"
       page.insert_html :top, period_tag_id, "<ul id=\"#{list_tag_id}\" class=\"task_list\" />"
-      page.insert_html :top, period_tag_id, :partial => '/tasks/fields_header', :locals => {:backlog => @task.backlog, :active => false, :work_done => work_done}
+      page.insert_html :top, period_tag_id, :partial => '/tasks/fields_header', :locals => {:project => @task.project, :active => false, :work_done => work_done}
       page.insert_html :top, period_tag_id, :partial => '/tasks/period_header', :locals => {:period => @task.period}
     end
     
-    page.insert_html :top, list_tag_id, :partial => '/tasks/task', :locals => {:active => false, :hidden => true, :highlight_task => false, :show_backlog => false}
+    page.insert_html :top, list_tag_id, :partial => '/tasks/task', :locals => {:task => @task, :active => false, :hidden => true, :highlight_task => false, :show_project => false}
     page.visual_effect :appear, "task_#{@task.id}"
   end
 
@@ -55,12 +55,12 @@ module BacklogsHelper
         page.insert_html :after, "active_period_#{@task.period.higher_item.id}", period_tag
       end
       page.insert_html :top, period_tag_id, %Q{<ul id="#{list_tag_id}" class="task_list" style="width: 100%;"/>}
-      fields_header = render(:partial => '/tasks/fields_header', :locals => { :backlog => @task.backlog, :active => true, :track_todo => @task.backlog.track_todo?, :track_done => @task.backlog.track_done?, :track_times => tasks_in_period.find {|t|t.period && t.period.active?} } )
+      fields_header = render(:partial => '/tasks/fields_header', :locals => { :project => @task.project, :active => true, :track_todo => @task.project.track_todo?, :track_done => @task.project.track_done?, :track_times => tasks_in_period.find {|t|t.period && t.period.active?} } )
       page.insert_html :top, period_tag_id, fields_header
       page.insert_html :top, period_tag_id, render(:partial => "/tasks/period_header", :locals => {:period => @task.period})
     end
     
-    page.insert_html(:top, list_tag_id, render(:partial => "/tasks/task", :locals => { :task => @task, :i => 1, :active => true, :highlight_task => false, :update => :spotlight, :hidden => true, :show_backlog => false }))
+    page.insert_html(:top, list_tag_id, render(:partial => "/tasks/task", :locals => { :task => @task, :i => 1, :active => true, :highlight_task => false, :update => :spotlight, :hidden => true, :show_project => false }))
     record page, sortable_element_js(list_tag_id, :url => { :action => :order }, :containment => @tasks.map{|t| t.period_id}.uniq.map{|p| "active_tasks_#{p}"}, :constraint => false)
 
     page[:no_tasks_message].hide

data/app/helpers/user_helper.rb

@@ -7,7 +7,7 @@ module UserHelper
   }.freeze unless defined? DEFAULT_HEAD_OPTIONS 
 
   def title_helper
-    "#{controller.controller_class_name} #{controller.action_name}"
+    "#{controller.class.name} #{controller.action_name}"
   end
 
   def head_helper(label, options = {})
@@ -35,7 +35,7 @@ module UserHelper
 
   def start_form_tag_helper(options = {})
     url = url_for(:action => "#{controller.action_name}")
-    "#{self.send(:form_tag, url, options)}"
+    "#{self.send(:form_tag, url, options)}".html_safe
   end
 
   def user_id

data/app/{models → mailers}/user_notify.rb

@@ -72,4 +72,5 @@ class UserNotify < ActionMailer::Base
     @sent_on    = Time.now
     @headers['Content-Type'] = "text/plain; charset=#{UserSystem::CONFIG[:mail_charset]}; format=flowed"
   end
+  
 end

data/app/models/absence.rb

@@ -7,8 +7,8 @@ class Absence < ActiveRecord::Base
 
   validates_uniqueness_of :on, :scope => :user_id
   
-  def validate
-    if PublicHoliday.exists? :on => on
+  validate do |a|
+    if PublicHoliday.exists? :on => a.on
       errors.add :on, "You cannot mark absence on a public holiday."
     end
   end

data/app/models/estimate.rb

@@ -10,8 +10,8 @@ class Estimate < ActiveRecord::Base
   validates_associated :task
   validates_presence_of :todo
     
-  def after_create
-    task.finish(Task::COMPLETED, false) if todo == 0
+  after_create do |e|
+    e.task.finish(Task::COMPLETED, false) if todo == 0
   end
   
 end

data/app/models/party.rb

@@ -23,6 +23,5 @@ class Party < ActiveRecord::Base
       0
     end
   end
-  
-  
+
 end

data/app/models/period.rb

@@ -8,9 +8,7 @@ class Period < ActiveRecord::Base
   validates_associated :party
   validates_uniqueness_of :position, :scope => :party_id
   
-  def validate
-    errors.add "A period cannot end before it starts" unless end_on >= start_on
-  end
+  validate { |p| p.errors.add "A period cannot end before it starts" unless p.end_on >= p.start_on }
   
   def self.find_active_or_future(check_tasks = false)
     periods = find(:all, :conditions => "end_on >= '#{Date.today.strftime '%Y-%m-%d'}'")
@@ -36,15 +34,15 @@ class Period < ActiveRecord::Base
     tasks.select {|task| task.active?}
   end
   
-  def most_frequent_backlog
-    all_backlogs = tasks.map {|t| t.backlog}.compact
-    return nil if all_backlogs.empty?
+  def most_frequent_project
+    all_projects = tasks.map {|t| t.project}.compact
+    return nil if all_projects.empty?
     freq = {}
-    all_backlogs.each do |b|
+    all_projects.each do |b|
       freq[b.id] ||= 0
       freq[b.id] += 1
     end
-    freq.to_a.sort_by {|backlog, count| -count}.first[0]
+    freq.to_a.sort_by {|project, count| -count}.first[0]
   end
   
   def active?(check_tasks = false)
@@ -133,7 +131,7 @@ class Period < ActiveRecord::Base
     last = first + 6
     works = tasks.map {|t| t.works_with_children}.flatten
     works.reject! {|work| work.hours == 0} unless with_empty_works
-    works.reject! {|work| work.user_id != user_id} if user_id && backlog.enable_users
+    works.reject! {|work| work.user_id != user_id} if user_id && project.enable_users
     by_day = (0..6).map do |i|
       works.select {|w| w.completed_at && w.completed_at.to_date == first + i}.sort do |w1, w2|
         if w1.completed_at != w2.completed_at
@@ -154,31 +152,32 @@ class Period < ActiveRecord::Base
   end
   
   def estimates?
-    not backlogs.find {|backlog| backlog.track_todo?}.nil?
+    not projects.find {|project| project.track_todo?}.nil?
   end
   
   def track_times?
-    not backlogs.find {|backlog| backlog.track_times?}.nil?
+    not projects.find {|project| project.track_times?}.nil?
   end
   
   def enable_subtasks?
-    not backlogs.find {|backlog| backlog.enable_subtasks?}.nil?
+    not projects.find {|project| project.enable_subtasks?}.nil?
   end
   
   def invoice?
-    not backlogs.find {|backlog| backlog.enable_invoicing?}.nil?
+    not projects.find {|project| project.enable_invoicing?}.nil?
   end
   
-  def backlogs
-    tasks.map {|task| task.backlog}.uniq
+  def projects
+    tasks.map {|task| task.project}.uniq
   end
   
   def burn_down_graph(size)
     begin
       require 'gruff'
-      rescue MissingSourceFile => e
-      return File.read("public/images/rmagick_#{size}.gif") if File.exists? "public/images/rmagick_#{size}.gif"
-      return File.read("public/images/rmagick.gif")
+    rescue MissingSourceFile => e
+      matching_file_name = Rails.root.to_s + "/public/images/rmagick_#{size}.gif"
+      return File.read(matching_file_name) if File.exists? matching_file_name
+      return File.read(Rails.root.to_s + "/public/images/rmagick.gif")
     end
     g = Gruff::Line.new(size)
     g.theme_37signals

data/app/models/{backlog.rb → project.rb}

@@ -1,4 +1,4 @@
-class Backlog < ActiveRecord::Base
+class Project < ActiveRecord::Base
   validates_presence_of :name
   validates_length_of :name, :allow_nil => false, :maximum => 64
   validates_uniqueness_of :name
@@ -11,7 +11,7 @@ class Backlog < ActiveRecord::Base
   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 => "backlog_id", :association_foreign_key => 'subscriber_user_id'
+  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]
 

data/app/models/sidebar.rb

@@ -1,7 +1,7 @@
 require 'action_view/helpers/url_helper'
 
 class Sidebar
-  include ActionView::Helpers::UrlHelper
+  include Rails.application.routes.url_helpers
   include ActionView::Helpers::TagHelper
   include ERB::Util
   
@@ -28,7 +28,7 @@ class Sidebar
     started_tasks = Task.find_started
     if not started_tasks.empty?
       links = started_tasks.map do |task|
-      "<li><a href=\"#{url_for :controller => 'tasks', :action => :list_started, :id => task.id}\">#{task.description}</a></li>"
+      "<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},

data/app/models/task.rb

@@ -9,7 +9,7 @@ class Task < ActiveRecord::Base
   MOVED = 'MOVED'
   ABORTED     = 'ABORTED'
   
-  belongs_to :backlog
+  belongs_to :project
   belongs_to :period
   belongs_to :ancestor_task, :class_name => 'Task', :foreign_key => 'previous_task_id' 
   belongs_to :customer
@@ -21,33 +21,33 @@ class Task < ActiveRecord::Base
   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 backlog_id = #{backlog_id}"} AND finished_at IS NULL'
+  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 :backlog_id, :if => Proc.new { |task| task.parent_id.nil? }
-  validates_presence_of :parent_id, :if => Proc.new { |task| task.backlog_id.nil? }
+  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 => :backlog_id
+  validates_presence_of :description, :if => :project_id
   
   validates_size_of :description, :maximum => 80, :if => :description
   
-  #validates_uniqueness_of :description, :scope => :backlog_id, :if => Proc.new {|task| task.backlog_id && task.previous_task_id.nil?}
+  #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, :backlog_id], :if => Proc.new {|task| task.period_id.nil? && task.parent_id.nil?}, :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}
   
-  def validate
-    if self.parent_id && (self.period_id || self.backlog_id)
-      errors.add :parent_id, "A subtask may have neither period nor backlog set."
+  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 new_record? && self.period && self.period.passed?
-      errors.add :period_id, "You may not add a task to a past period."
+    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
   
@@ -61,7 +61,7 @@ class Task < ActiveRecord::Base
     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.backlog.name, t.root_task.period ? t.root_task.period.end_on : 0, t.position || 0]
+      [t.root_task.project.name, t.root_task.period ? t.root_task.period.end_on : 0, t.position || 0]
     end
   end
   
@@ -173,7 +173,7 @@ class Task < ActiveRecord::Base
       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.backlog == root_task.backlog
+        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
@@ -189,7 +189,7 @@ class Task < ActiveRecord::Base
           new_parent = Task.find_descendant(new_period.id, parent.ancestor_id)
           new_task.parent = new_parent
         else
-          new_task.backlog = root_task.backlog
+          new_task.project = root_task.project
           new_task.period = new_period
         end
         new_task.description = self.description
@@ -279,35 +279,35 @@ class Task < ActiveRecord::Base
   end
   
   def invoicing?
-    root_task.backlog.enable_invoicing?
+    root_task.project.enable_invoicing?
   end
   
   def track_done?
-    backlog.track_done?
+    project.track_done?
   end
 
   def track_times?
-    backlog.try :track_times?
+    project.try :track_times?
   end
   
   def track_todo?
-    root_task.backlog.track_todo?
+    root_task.project.track_todo?
   end
   
   def enable_subtasks?
-    root_task.backlog.enable_subtasks?
+    root_task.project.enable_subtasks?
   end
   
   def enable_users?
-    root_task.backlog.enable_users?
+    root_task.project.enable_users?
   end
   
   def enable_customer?
-    root_task.backlog.enable_customer?
+    root_task.project.enable_customer?
   end
   
   def enable_invoicing?
-    root_task.backlog.enable_invoicing?
+    root_task.project.enable_invoicing?
   end
   
   alias_method :old_period, :period
@@ -315,9 +315,9 @@ class Task < ActiveRecord::Base
     old_period || root_task.old_period
   end
   
-  alias_method :old_backlog, :backlog
-  def backlog
-    old_backlog || root_task.old_backlog
+  alias_method :old_project, :project
+  def project
+    old_project || root_task.old_project
   end
   
   def depth
@@ -380,7 +380,7 @@ class Task < ActiveRecord::Base
     end
     
     new_work.user = current_user
-    new_work.backlog_id = backlog.id
+    new_work.project_id = project.id
     new_work.save!
     works << new_work
   end
@@ -412,7 +412,7 @@ class Task < ActiveRecord::Base
   
   def description_with_parents
     if parent.nil?
-      "#{backlog.name}: #{description}"
+      "#{project.name}: #{description}"
     else
       "#{parent.description_with_parents} - #{description}"
     end

data/app/models/user.rb

@@ -1,4 +1,5 @@
 require 'digest/sha1'
+require 'clock'
 
 # this model expects a certain database layout and its based on the name/login pattern. 
 #class User < ActiveRecord::Base
@@ -124,15 +125,15 @@ class User < Party
 
   def crypt_password
     if @password_needs_confirmation
-      write_attribute("salt", self.class.hashed("salt-#{Clock.now}"))
-      write_attribute("salted_password", self.class.salted_password(salt, self.class.hashed(@password)))
+      self[:salt] = self.class.hashed("salt-#{Clock.now}")
+      self[:salted_password] = self.class.salted_password(salt, self.class.hashed(@password))
     end
   end
 
   def new_security_token
     expiry = Time.at(Clock.now.to_i + self.class.token_lifetime)
-    write_attribute('security_token', self.class.hashed(self.salted_password + Clock.now.to_i.to_s + rand.to_s))
-    write_attribute('token_expiry', expiry)
+    self[:security_token] = self.class.hashed(self.salted_password + Clock.now.to_i.to_s + rand.to_s)
+    self[:token_expiry] = expiry
 #    update_without_callbacks
     update
     return self.security_token

data/app/models/work.rb

@@ -4,11 +4,11 @@ class Work < ActiveRecord::Base
   
   belongs_to :task
   belongs_to :user
-  belongs_to :backlog
+  belongs_to :project
   belongs_to :customer
   
   validates_associated :task
-  validates_presence_of :backlog
+  validates_presence_of :project
   validates_presence_of :started_on
   validates_presence_of :start_time, :if => :track_times?
   
@@ -18,7 +18,7 @@ class Work < ActiveRecord::Base
   end
   
   def track_times?
-    backlog && backlog.track_times?
+    project && project.track_times?
   end
   
   # Return an array with an array of works per day:
@@ -44,53 +44,53 @@ class Work < ActiveRecord::Base
   
   # Return a hash with work accounts as keys an array of work hours totals per day as values:
   # {
-  #   <#Backlog#1> => [  8,   7,   9,  12,   4, nil, nil],
-  #   <#Backlog#2> => [nil,   1, nil, nil,   4, nil, nil],
-  #   <#Backlog#3> => [nil, nil, nil, nil, nil,   4,   3],
+  #   <#Project#1> => [  8,   7,   9,  12,   4, nil, nil],
+  #   <#Project#2> => [nil,   1, nil, nil,   4, nil, nil],
+  #   <#Project#3> => [nil, nil, nil, nil, nil,   4,   3],
   # ]
-  def self.works_for_week_by_backlog(year, week_no, user = current_user)
+  def self.works_for_week_by_project(year, week_no, user = current_user)
     first_date = Date.commercial(year, week_no, 1)
     last_date = first_date + 6
     works = find(:all, :conditions => "user_id #{user ? " = #{user.id}" : "IS NULL"} AND started_on BETWEEN '#{first_date}' AND '#{last_date}'", :order => 'completed_at, started_on, start_time')
     result = {}
     works.each do |work|
       day_of_week = work.started_on.cwday - 1
-      result[work.backlog] ||= []
-      result[work.backlog][day_of_week] ||= BigDecimal('0')
-      result[work.backlog][day_of_week] += work.hours
+      result[work.project] ||= []
+      result[work.project][day_of_week] ||= BigDecimal('0')
+      result[work.project][day_of_week] += work.hours
     end
-    result.values.each {|backlog_totals| backlog_totals[6] ||= nil}
-    result.values.each {|backlog_totals| (0..6).each {|i| backlog_totals[i] = nil if backlog_totals[i] == 0}}
+    result.values.each {|project_totals| project_totals[6] ||= nil}
+    result.values.each {|project_totals| (0..6).each {|i| project_totals[i] = nil if project_totals[i] == 0}}
     result
   end
   
   # Return a hash with an array of work totals per day:
   # {
-  #   backlog1.id => [[m, t, w, t, f, s, s], [m, t, w, t, f, s, s]],
-  #   backlog2.id => [<work for monday>, 0, <work for wednesday>, <work for thursday>, <work for friday>, 0, <work for sunday>]
+  #   project1.id => [[m, t, w, t, f, s, s], [m, t, w, t, f, s, s]],
+  #   project2.id => [<work for monday>, 0, <work for wednesday>, <work for thursday>, <work for friday>, 0, <work for sunday>]
   # }
   def self.work_totals_for_week(year, week_no, user = current_user)
     first = Date.commercial(year, week_no, 1)
     last = first + 6
     works = find(:all, :conditions => "completed_at IS NOT NULL AND started_on BETWEEN '#{first}' AND '#{last}'", :order => 'started_on, start_time, completed_at')
-    totals_per_backlog = {}
-    works.map{|w| w.backlog}.uniq.each do |backlog|
-      totals_per_backlog[backlog.id] = [[], []]
+    totals_per_project = {}
+    works.map{|w| w.project}.uniq.each do |project|
+      totals_per_project[project.id] = [[], []]
        (0..6).each do |day|
-        works_for_day = works.select {|work| (work.backlog == backlog) && (work.started_on == (first + day)) && ((user.nil? && work.user_id.nil?) || (user && work.user_id == user.id)) }
+        works_for_day = works.select {|work| (work.project == project) && (work.started_on == (first + day)) && ((user.nil? && work.user_id.nil?) || (user && work.user_id == user.id)) }
         invoice_works_for_day = works_for_day.select {|work| work.invoice? }
         internal_works_for_day = works_for_day.select {|work| !work.invoice? }
         
         invoice_day_total = invoice_works_for_day.reduce(BigDecimal('0')){|total, work| total += work.hours}
         internal_day_total = internal_works_for_day.reduce(BigDecimal('0')){|total, work| total += work.hours}
-        totals_per_backlog[backlog.id][0] << invoice_day_total
-        totals_per_backlog[backlog.id][1] << internal_day_total
+        totals_per_project[project.id][0] << invoice_day_total
+        totals_per_project[project.id][1] << internal_day_total
       end
     end
-    totals_per_backlog.reject! do |backlog_id, day_totals|
+    totals_per_project.reject! do |project_id, day_totals|
       !day_totals[0].find{|day_total| day_total > 0} && !day_totals[1].find{|day_total| day_total > 0}
     end
-    totals_per_backlog
+    totals_per_project
   end
   
   def self.find_work_for_day(date, user = current_user)
@@ -157,6 +157,12 @@ class Work < ActiveRecord::Base
     self.started_on = Date.new(t.year, t.month, t.day)
     self.start_time = TimeOfDay.new(t.hour, t.min)
   end
+
+  def started_on=(new_value)
+    super
+    self.completed_at_time = completed_at_time.to_s if self.started_on_was.nil?
+    self.started_on
+  end
   
   def completed_at_time
     completed_at && completed_at.time_of_day
@@ -169,7 +175,7 @@ class Work < ActiveRecord::Base
       return
     end
     time_of_day = TimeOfDay.parse(new_value)
-    date = started_on || completed_at.to_date || Date.today
+    date = started_on || completed_at.try(:to_date) || Date.today
     self.completed_at = date.at time_of_day
   end