backlog 0.37.2 → 0.41.4

data/app/helpers/welcome_helper.rb

@@ -1,2 +0,0 @@
-module WelcomeHelper
-end

data/app/helpers/work_locks_helper.rb

@@ -1,2 +0,0 @@
-module WorkLocksHelper
-end

data/app/helpers/works_helper.rb

@@ -1,5 +0,0 @@
-module WorksHelper
-  def week_date(day)
-    Date.commercial(@year, @week, day).strftime('%d/%m')
-  end
-end

data/app/mailers/user_notify.rb

@@ -1,76 +0,0 @@
-class UserNotify < ActionMailer::Base
-  
-  def signup(user, password, url=nil)
-    setup_email(user)
-
-    # Email header info
-    @subject += "Welcome to #{UserSystem::CONFIG[:app_name]}!"
-
-    # Email body substitutions
-    @body["name"] = "#{user.first_name} #{user.last_name}"
-    @body["login"] = user.login
-    @body["password"] = password
-    @body["url"] = url || UserSystem::CONFIG[:app_url].to_s
-    @body["app_name"] = UserSystem::CONFIG[:app_name].to_s
-  end
-
-  def forgot_password(user, url=nil)
-    setup_email(user)
-
-    # Email header info
-    @subject += "Forgotten password notification"
-
-    # Email body substitutions
-    @body["name"] = "#{user.first_name} #{user.last_name}"
-    @body["login"] = user.login
-    @body["url"] = url || UserSystem::CONFIG[:app_url].to_s
-    @body["app_name"] = UserSystem::CONFIG[:app_name].to_s
-  end
-
-  def change_password(user, password, url=nil)
-    setup_email(user)
-
-    # Email header info
-    @subject += "Changed password notification"
-
-    # Email body substitutions
-    @body["name"] = "#{user.first_name} #{user.last_name}"
-    @body["login"] = user.login
-    @body["password"] = password
-    @body["url"] = url || UserSystem::CONFIG[:app_url].to_s
-    @body["app_name"] = UserSystem::CONFIG[:app_name].to_s
-  end
-
-  def monitoring(user, monitoring_user, action)
-    setup_email(user)
-
-    @subject += "#{monitoring_user.name} has #{l(action)} monitoring your time sheets."
-
-    @body["app_name"] = UserSystem::CONFIG[:app_name].to_s
-    @body["user"] = user
-    @body["monitoring_user"] = monitoring_user
-    @body["action"] = action
-  end
-
-  def monitoring_invitation(user, monitoring_user, monitor_url)
-    setup_email(user)
-
-    @subject += "#{user.name} has invited you to monitor his/her time sheets."
-
-    @body["app_name"] = UserSystem::CONFIG[:app_name].to_s
-    @body["user"] = user
-    @body["monitoring_user"] = monitoring_user
-    @body["monitor_url"] = monitor_url
-  end
-
-  private
-  
-  def setup_email(user)
-    @recipients = "#{user.email}"
-    @from       = UserSystem::CONFIG[:email_from].to_s
-    @subject    = "[#{UserSystem::CONFIG[:app_name]}] "
-    @sent_on    = Time.now
-    @headers['Content-Type'] = "text/plain; charset=#{UserSystem::CONFIG[:mail_charset]}; format=flowed"
-  end
-  
-end

data/app/models/absence.rb

@@ -1,27 +0,0 @@
-class Absence < ActiveRecord::Base
-  extend UserSystem
-   
-  validates_presence_of :user_id
-  validates_presence_of :on
-  validates_presence_of :reason
-
-  validates_uniqueness_of :on, :scope => :user_id
-  
-  validate do |a|
-    if PublicHoliday.exists? :on => a.on
-      errors.add :on, "You cannot mark absence on a public holiday."
-    end
-  end
-  
-  # Return an array of either an absence or nil for each day of the given week.
-  def self.find_by_week(year, week, user = current_user)
-    first_date = Date.commercial(year, week, 1)
-    last_date = first_date + 6
-    results = self.find(:all, :conditions => ['"on" BETWEEN ? AND ? AND user_id = ?', first_date, last_date, user && user.id], :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/chart.rb

@@ -1,5 +0,0 @@
-module Chart
-  THUMBNAIL = 270
-  NORMAL = 640
-  LARGE = '1368x768'
-end

data/app/models/clock.rb

@@ -1,14 +0,0 @@
-class Clock
-  def self.at( *params )
-    #TODO fix this
-    eval("Time.at #{params.join(',')}")
-  end
-
-  def self.now
-    Time.now
-  end
-
-  def self.time=
-    raise "Cannot set real Clock class"
-  end
-end

data/app/models/configuration.rb

@@ -1,2 +0,0 @@
-class Configuration < ActiveRecord::Base
-end

data/app/models/customer.rb

@@ -1,2 +0,0 @@
-class Customer < ActiveRecord::Base
-end

data/app/models/estimate.rb

@@ -1,17 +0,0 @@
-# Holds a value given by a user at a certain time estimating how many work-points (gummybears?)
-# still remain until this task is completed.
-#
-# A value of zero indicated that the task is completed.
-class Estimate < ActiveRecord::Base
-  belongs_to :task
-  belongs_to :user
-
-  validates_presence_of :task_id
-  validates_associated :task
-  validates_presence_of :todo
-    
-  after_create do |e|
-    e.task.finish(Task::COMPLETED, false) if todo == 0
-  end
-  
-end

data/app/models/group.rb

@@ -1,16 +0,0 @@
-class Group < Party
-  class_table_inheritance
-
-  # TODO (uwe): We need to specify :join_table, :foreign_key and :association_foreign_key
-  # even if they follow the defaults since ClassTableInheritanceInRails breaks it.
-  has_and_belongs_to_many :users, :join_table => "groups_users", :foreign_key => "group_id", :association_foreign_key => 'user_id'
-
-  validates_presence_of :name
-  validates_length_of :name, :allow_nil => false, :maximum => 255
-  validates_uniqueness_of :name
-
-  def includes?(user)
-    return users.include?(user)
-  end
-
-end

data/app/models/party.rb

@@ -1,27 +0,0 @@
-class Party < ActiveRecord::Base
-  has_many :periods, :order => :position, :dependent => :destroy
-  
-  def to_sym
-    self.class.name.downcase.to_sym
-  end
-  
-  def controller
-    self.class.name.downcase.pluralize
-  end
-  
-  def icon
-    to_sym.to_s + '.png'
-  end
-  
-  def current_speed
-    completed_periods = periods.select {|p| p.end_on < Date.today}
-    if last_completed = completed_periods.last
-      last_completed.speed
-    elsif active_period = periods.to_ary.find {|p| p.active?}
-      active_period.speed
-    else
-      0
-    end
-  end
-
-end

data/app/models/period.rb

@@ -1,251 +0,0 @@
-class Period < ActiveRecord::Base
-  extend UserSystem
-  include UserSystem
-  
-  belongs_to :party
-  acts_as_list :scope => :party, :order => :position
-  has_many :tasks, :order => 'position, finished_at', :dependent => :destroy
-  validates_associated :party
-  validates_uniqueness_of :position, :scope => :party_id
-  
-  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'}'")
-    if (check_tasks)
-      ended_periods_with_open_tasks = Task.find(:all, :conditions => ['finished_at IS NULL AND period_id NOT IN (?)', periods.map{|p| p.id}]).map {|t| t.period}
-      periods + ended_periods_with_open_tasks
-    end
-    periods.select {|p| p.party.includes?(current_user)}
-  end
-  
-  def speed
-    start_todo = estimate_data(start_on, true)
-    end_todo = estimate_data(end_on, true)
-    days = end_on - start_on
-    return (start_todo - end_todo).to_f / days
-  end
-  
-  def completed_tasks
-    tasks.select {|task| task.completed?}
-  end
-  
-  def open_tasks
-    tasks.select {|task| task.active?}
-  end
-  
-  def most_frequent_project
-    all_projects = tasks.map {|t| t.project}.compact
-    return nil if all_projects.empty?
-    freq = {}
-    all_projects.each do |b|
-      freq[b.id] ||= 0
-      freq[b.id] += 1
-    end
-    freq.to_a.sort_by {|project, count| -count}.first[0]
-  end
-  
-  def active?(check_tasks = false)
-    start_on <= Date.today && (end_on >= Date.today || (check_tasks && active_tasks?))
-  end
-
-  def active_tasks?
-    not tasks.select {|task| task.active?}.empty?
-  end
-  
-  def future?
-    start_on >= Date.today
-  end
-  
-  def active_or_future?(check_tasks = false)
-    end_on >= Date.today || (check_tasks && active_tasks?)
-  end
-  
-  def passed?
-    end_on < Date.today
-  end
-  
-  def estimate_data(date, actual=false)
-    total = BigDecimal('0')
-    tasks.each do |task|
-      total += task.estimate_data(date, actual)
-    end
-    total
-  end  
-  
-  def work_data(date)
-    total = BigDecimal('0')
-    tasks.each do |task|
-      total += task.work_data(date)
-    end
-    total
-  end  
-  
-  def required_speed
-    todo = estimate_data(Date.today)
-    remaining_days = end_on - Date.today
-    if todo == 0
-      0
-    elsif remaining_days > 0
-      todo / remaining_days
-    elsif remaining_days == 0
-      todo
-    else
-      todo * (-remaining_days)
-    end
-  end
-  
-  def to_s
-    name
-  end
-  
-  def name
-    "#{party.name}##{position}"
-  end
-  
-  def dates
-    all_dates = []
-     (start_on-1).upto(end_on) {|date| all_dates << date}
-    return all_dates
-  end
-  
-  def recorded_dates
-    dates = []
-    if start_on > Date.today
-      dates << (start_on-1)
-    elsif end_on < Date.today
-     (start_on-1).upto(end_on) {|date| dates << date}
-    else
-     (start_on-1).upto(Date.today) {|date| dates << date}
-    end  
-    return dates
-  end
-  
-  # Return an array with a work object per day:
-  # [
-  #   [<work>, <work>, <work>, <work>, <work>, nil, nil],
-  #   [<work>, nil,    <work>, <work>, <work>, nil, nil]
-  # ]
-  def works_for_week(week_no, with_empty_works = false, user_id = nil)
-    first = Date.commercial(Date.today.year, week_no, 1)
-    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 && 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
-          w1.completed_at <=> w2.completed_at
-        elsif w1.started_at && w2.started_at
-          w1.started_at <=> w2.started_at
-        elsif w1.started_at
-          1
-        else
-          -1
-        end
-      end
-    end
-    by_day.each {|d| d[works.size] = d[works.size]}
-    by_line = by_day.transpose
-    by_line = by_line.select {|l| l.compact.size > 0}
-    by_line
-  end
-  
-  def estimates?
-    not projects.find {|project| project.track_todo?}.nil?
-  end
-  
-  def track_times?
-    not projects.find {|project| project.track_times?}.nil?
-  end
-  
-  def enable_subtasks?
-    not projects.find {|project| project.enable_subtasks?}.nil?
-  end
-  
-  def invoice?
-    not projects.find {|project| project.enable_invoicing?}.nil?
-  end
-  
-  def projects
-    tasks.map {|task| task.project}.uniq
-  end
-  
-  def burn_down_graph(size)
-    begin
-      require 'gruff'
-    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
-    g.title = l(:burn_down_chart) + " " + name
-    g.font = '/usr/share/fonts/bitstream-vera/Vera.ttf'
-    g.legend_font_size = 14
-    g.hide_dots = true
-    g.colors = %w{#0000ff #ff8800}
-    if track_work?
-      g.colors += %w{#00ff00}
-    end
-    if previous_period = higher_item
-      g.colors += %w{#cccccc #cccccc}
-    end
-    g.colors += %w{#8888ff #d7a790}
-    
-    recorded_dates = self.recorded_dates
-    
-    observed_todo_data = get_todo_data(recorded_dates)
-    g.data("#{l :todo} (#{l :obs})", observed_todo_data)
-    g.data(l(:projection), projection_data(observed_todo_data))
-    
-    actual_todo_data = get_todo_data(recorded_dates, true)
-    g.data("#{l :todo}", actual_todo_data)
-    g.data(l(:projection), projection_data(actual_todo_data))
-    
-    g.data(l(:done), get_work_data(recorded_dates)) if track_work?
-    
-    if previous_period = higher_item
-      g.data("#{l :previous_abr} #{l :obs}", previous_period.get_todo_data(previous_period.dates))
-      g.data("#{l :previous_abr}", previous_period.get_todo_data(previous_period.dates, true))
-    end
-    
-    g.minimum_value = 0
-    
-    all_dates = dates
-    labels = {1 => all_dates[1].to_s, all_dates.length-1 => all_dates.last.to_s}
-    labels.merge({all_dates.index(Date.today) => Date.today.to_s}) if all_dates.index(Date.today) && (all_dates.index(Date.today) / all_dates.length) > 0.10
-    g.labels = labels
-    
-    # g.draw_vertical_legend
-    
-    g.maximum_value = (g.maximum_value.to_s[0..0].to_i + 1) * (10**Math::log10(g.maximum_value.to_i).to_i) if g.maximum_value > 0
-    g.to_blob
-  end
-  
-  def get_todo_data(dates, actual=false)
-    dates.map { |date| estimate_data(date, actual) }
-  end
-  
-  def get_work_data(dates)
-    dates.map { |date| work_data(date) }
-  end
-  
-  def projection_data(observed_todo_data)
-    if observed_todo_data.length <= 1
-      velocity = party.current_speed
-    else
-      velocity = (observed_todo_data[0] - observed_todo_data[-1]).to_f / (observed_todo_data.length-1)
-    end
-    projection_data = dates.map do |date|
-      if date < Date.today 
-        nil
-      else
-        value = observed_todo_data[0] - (date-start_on+1).to_f*velocity
-        value >= 0 ? value : 0
-      end
-    end
-  end
-  
-end