backlog 0.37.2 → 0.41.4

data/app/models/task_file.rb

@@ -1,7 +0,0 @@
-class TaskFile < ActiveRecord::Base
-  belongs_to :task
-  
-  def image?
-    content_type =~ /^image\//
-  end
-end

data/app/models/task_notify.rb

@@ -1,27 +0,0 @@
-class TaskNotify < ActionMailer::Base
-  def invite(inviter, invitee, task, task_url, grab_url)
-    setup_email(invitee)
-
-    # Email header info
-    @subject += "#{inviter.name} has invited you to grab task: #{task.id}."
-
-    # Email body substitutions
-    @body["app_name"] = UserSystem::CONFIG[:app_name].to_s
-    @body["app_url"] = UserSystem::CONFIG[:app_url].to_s
-    @body["task"] = task
-    @body["task_url"] = task_url
-    @body["grab_url"] = grab_url
-    @body["inviter"] = inviter
-    @body["invitee"] = invitee
-  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/user.rb

@@ -1,146 +0,0 @@
-require 'digest/sha1'
-require 'clock'
-
-# this model expects a certain database layout and its based on the name/login pattern. 
-#class User < ActiveRecord::Base
-class User < 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 :groups, :join_table => "groups_users", :foreign_key => "user_id", :association_foreign_key => 'group_id'
-  has_and_belongs_to_many :work_lock_subscribers, :class_name => 'User', :join_table => "user_work_lock_subscriptions", :foreign_key => "user_id", :association_foreign_key => 'subscriber_user_id'
-  has_and_belongs_to_many :work_lock_subscriptions, :class_name => 'User', :join_table => "user_work_lock_subscriptions", :association_foreign_key => "user_id", :foreign_key => 'subscriber_user_id'
-  has_many :works, :foreign_key => :user_id, :order => :completed_at
-  has_many :work_locks, :foreign_key => :user_id, :order => :end_on
-
-  attr_accessor :password_needs_confirmation
-
-  after_save '@password_needs_confirmation = false'
-  after_validation :crypt_password
-
-  validates_presence_of :login
-  validates_length_of :login, :within => 3..40
-  validates_uniqueness_of :login
-  
-  validates_presence_of :email
-  validates_length_of :email, :allow_nil => false, :maximum => 60, :if => :email
-  validates_uniqueness_of :email
-
-  # This is commented out since I want to allow empty passwords
-#  validates_presence_of :password, :if => :validate_password?
-  validates_confirmation_of :password, :if => :validate_password?
-  # This is commented out since I want to allow empty passwords
-#  validates_length_of :password, { :minimum => 5, :if => :validate_password? }
-  validates_length_of :password, { :maximum => 40, :if => :validate_password? }
-
-  validates_length_of :first_name, :allow_nil => true, :maximum => 40
-  validates_length_of :last_name, :allow_nil => true, :maximum => 40
-
-  validates_length_of :role, :allow_nil => true, :maximum => 40
-
-  validates_length_of :security_token, :allow_nil => true, :maximum => 40
-  validates_inclusion_of :deleted, :in => [true, false], :allow_nil => true, :message => I18n.translate('activerecord.errors.messages')[:blank]
-
-  def initialize(attributes = nil)
-    super
-    @password_needs_confirmation = false
-  end
-
-  def controller
-    self.class.name.downcase
-  end
-  
-  def self.authenticate(login, pass)
-    u = find(:first, :conditions => ["login = ? AND verified = ? AND deleted = ?", login, true, false])
-    return nil if u.nil?
-    find(:first, :conditions => ["login = ? AND salted_password = ? AND verified = ?", login, salted_password(u.salt, hashed(pass)), true])
-  end
-
-  def self.authenticate_by_token(id, token)
-    # Allow logins for deleted accounts, but only via this method (and
-    # not the regular authenticate call)
-    logger.info "Attempting authorization of #{id} with #{token}"
-    u = find(:first, :conditions => ["id = ? AND security_token = ?", id, token])
-    if u.nil? || u.token_expired?
-      logger.info "Not authenticated"
-      return nil
-    end
-    logger.info "Authenticated by token: #{u.inspect}"
-    u.update_attribute :verified, true
-    return u
-  end
-
-  def token_expired?
-    self.security_token.nil? or self.token_expiry.nil? or (Clock.now > self.token_expiry)
-  end
-
-  def token_stale?
-    token_expired? or Clock.now.to_i >= (self.token_expiry.to_i - self.class.token_lifetime / 2)
-  end
-
-  def generate_security_token
-    if token_stale?
-      token = new_security_token
-      return token
-    else
-      return self.security_token
-    end
-  end
-
-  def change_password(pass, confirm = nil)
-    self.password = pass
-    self.password_confirmation = confirm.nil? ? pass : confirm
-    @password_needs_confirmation = true
-  end
-
-  def self.token_lifetime
-    UserSystem::CONFIG[:security_token_life_hours] * 60 * 60
-  end
-
-  def name
-    [first_name, last_name].compact.join(' ')
-  end
-  
-  def includes?(user)
-    return user == self
-  end
-
-  def users
-    [self]
-  end
-  
-  protected
-
-  attr_accessor :password, :password_confirmation
-
-  def validate_password?
-    @password_needs_confirmation
-  end
-
-  def self.hashed(str)
-    hashed_password = Digest::SHA1.hexdigest("change-me--#{str}--")[0..39]
-    return hashed_password
-  end
-
-  def crypt_password
-    if @password_needs_confirmation
-      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)
-    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
-  end
-
-  def self.salted_password(salt, hashed_password)
-    salted_password = hashed(salt + hashed_password)
-    return salted_password
-  end
-end

data/app/models/work.rb

@@ -1,191 +0,0 @@
-class Work < ActiveRecord::Base
-  extend UserSystem
-  include UserSystem
-  
-  belongs_to :task
-  belongs_to :user
-  belongs_to :project
-  belongs_to :customer
-  
-  validates_associated :task
-  validates_presence_of :project
-  validates_presence_of :started_on
-  validates_presence_of :start_time, :if => :track_times?
-  
-  def initialize(*args)
-    super
-    self.invoice = true if self.invoice.nil?
-  end
-  
-  def track_times?
-    project && project.track_times?
-  end
-  
-  # Return an array with an array of works per day:
-  # [
-  #   [m0, t0, w0, t0, f0, nil, nil],
-  #   [m1, t1, w1, t1, f1, nil, nil],
-  #   [m2, t2, nil,t2, nil,nil, nil],
-  #   [nil,t2, nil,nil,nil,nil, nil],
-  # ]
-  def self.works_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')
-    length = 0
-    works_per_day = (0..6).map do |day|
-      works_for_day = works.select {|work| work.started_on == (first + day) && (work.user_id.nil? || (user && work.user_id == user.id)) }
-      length = [length, works_for_day.length].max
-      works_for_day
-    end
-    works_per_day.each {|works_for_day| works_for_day[length-1] ||= nil} if length > 0
-    works_by_row = works_per_day.transpose
-  end
-  
-  # Return a hash with work accounts as keys an array of work hours totals per day as values:
-  # {
-  #   <#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_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.project] ||= []
-      result[work.project][day_of_week] ||= BigDecimal('0')
-      result[work.project][day_of_week] += work.hours
-    end
-    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:
-  # {
-  #   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_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.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_project[project.id][0] << invoice_day_total
-        totals_per_project[project.id][1] << internal_day_total
-      end
-    end
-    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_project
-  end
-  
-  def self.find_work_for_day(date, user = current_user)
-    Work.find(:all, :conditions => "started_on = '#{date}' AND user_id = #{user.id}",
-    :order => 'start_time, completed_at')
-  end
-
-  def self.work_sum_per_month(year, month_no, user = current_user)
-    first = Date.new(year, month_no, 1)
-    last = Date.new(year, month_no, -1)
-    count = find_by_sql("select sum(hours) from works where completed_at IS NOT NULL AND started_on BETWEEN '#{first}' AND '#{last}' AND user_id = #{user.id}")[0]['sum']
-    count ? count : 0
-  end
-  
-  def self.invoice_work_sum_per_month(year, month_no, user = current_user)
-    first = Date.new(year, month_no, 1)
-    last = Date.new(year, month_no, -1)
-    count = find_by_sql("select sum(hours) from works where invoice = true AND completed_at IS NOT NULL AND started_on BETWEEN '#{first}' AND '#{last}' AND user_id = #{user.id}")[0]['sum']
-    count ? count : 0
-  end  
-  
-  def self.work_sum_per_week(year, week_no, user = current_user)
-    first = Date.commercial(year, week_no, 1)
-    last = first + 6
-    count = find_by_sql("select sum(hours) from works where completed_at IS NOT NULL AND started_on BETWEEN '#{first}' AND '#{last}' AND user_id = #{user.id}")[0]['sum']
-    count ? count : 0
-  end
-
-  def self.invoice_work_sum_per_week(year, week_no, user = current_user)
-    first = Date.commercial(year, week_no, 1)
-    last = first + 6
-    count = find_by_sql("select sum(hours) from works where invoice = true AND completed_at IS NOT NULL AND started_on BETWEEN '#{first}' AND '#{last}' AND user_id = #{user.id}")[0]['sum']
-    count ? count : 0
-  end
-  
-  def self.work_sum_per_day(date, user = current_user)
-    count = find_by_sql("select sum(hours) from works where completed_at IS NOT NULL AND started_on = '#{date}' AND user_id = #{user.id}")[0]['sum']
-    count ? count : 0
-  end
-  
-  def self.invoice_work_sum_per_day(date, user = current_user)
-    count = find_by_sql("select sum(hours) from works where invoice = true AND completed_at IS NOT NULL AND started_on = '#{date}' AND user_id = #{user.id}")[0]['sum']
-    count ? count : 0
-  end
-
-  
-  def started?
-    completed_at.nil?
-  end
-  
-  def started_at
-    started_on && start_time && started_on.at(start_time)
-  end
-  
-  def started_at=(new_value)
-    case new_value
-      when String:
-      t = Time.parse(new_value)
-      when Time:
-      t = new_value
-    else
-      raise "Illegal argument: #{new_value.inspect}"
-    end
-    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
-  end
-  
-  def completed_at_time=(new_value)
-    new_value.strip!
-    if new_value.empty?
-      self.completed_at = nil
-      return
-    end
-    time_of_day = TimeOfDay.parse(new_value)
-    date = started_on || completed_at.try(:to_date) || Date.today
-    self.completed_at = date.at time_of_day
-  end
-  
-  def calculate_hours!
-    return unless started_at && completed_at
-    self.hours = calculate_hours
-  end
-  
-  def calculate_hours
-    BigDecimal(((completed_at - started_at) / 3600).to_s).round(3)
-  end
-  
-end

data/app/models/work_lock.rb

@@ -1,11 +0,0 @@
-class WorkLock < ActiveRecord::Base
-  extend UserSystem
-  
-  belongs_to :user
-  
-  def self.find_by_week(year, week)
-    first_date = Date.commercial(year, week, 1)
-    last_date = first_date + 6
-    result = self.find(:first, :conditions => ['user_id = ? AND start_on <= ? AND end_on >= ?', current_user.id, first_date, last_date])
-  end
-end

data/app/models/work_lock_nagger.rb

@@ -1,60 +0,0 @@
-class WorkLockNagger
-  include Rails.application.routes.url_helpers
-  
-  def initialize(start_delay = 1)
-    @start_delay = start_delay
-  end
-  
-  def nag
-    sleep @start_delay.minute
-    puts "Work Lock Nagger started"
-    begin
-      if File.exists? APP_CONFIG_FILE
-        config = YAML::load(ERB.new(IO.read(APP_CONFIG_FILE)).result) || {}
-        app_url = config[:app_url]
-      end
-      if app_url
-        url = app_url + 'works/weekly_work_sheet'
-      else      
-        host = Socket::gethostname
-        port = config && config[:port] || 3000
-        url = url_for(:host => host, :port => port, :controller => 'works', :action => :weekly_work_sheet)
-      end
-    rescue Exception => e
-      puts "Work Lock Nagger Exception"
-      puts e.message
-      puts e.backtrace
-      exit 1
-    end
-    
-    loop do
-      puts "Nagging"
-      begin
-        late_work_locks = WorkLock.find(
-                                        :all, 
-                                        :conditions => ["end_on < ? and not exists (select id from work_locks wl2 where wl2.user_id = work_locks.user_id and wl2.end_on > work_locks.end_on)", 1.week.ago.monday ])
-        
-        late_users = late_work_locks.map{|wl| wl.user}.uniq
-        late_users.each do |u|
-          missing_date = (u.work_locks.last.end_on + 7)
-          year = missing_date.year
-          week = missing_date.cweek
-          WorkLockNotify.deliver_nag(u, week, url + "/#{year}/#{week}")
-        end
-        now = Time.now
-        next_nag_time = Time.local(now.year, now.month, now.day, 10, 0, 0)
-        next_nag_time += 1.day if next_nag_time <= now
-        sleep_duration = next_nag_time - now
-        puts "Sleeping #{sleep_duration.to_i / 3600} hours #{(sleep_duration.to_i % 3600) / 60} minutes and #{sleep_duration.to_i % 60} seconds."
-        puts "From #{now} to #{next_nag_time}."
-        sleep sleep_duration
-      rescue Exception => e
-        p e
-        puts e.backtrace
-        sleep 5.minutes
-      end
-      puts "Nag ends"; STDOUT.flush
-    end
-  end
-  
-end