backlog 0.37.2 → 0.41.4

data/db/migrate/016_add_invoicable_flag.rb

@@ -1,11 +0,0 @@
-class AddInvoicableFlag < ActiveRecord::Migration
-  def self.up
-    add_column :backlogs, :invoice_code, :string, :size => 16 
-    add_column :works, :invoice, :boolean
-  end
-
-  def self.down
-    remove_column :works, :invoice
-    remove_column :backlogs, :invoice_code
-  end
-end

data/db/migrate/017_increase_backlog_name_limit.rb

@@ -1,10 +0,0 @@
-class IncreaseBacklogNameLimit < ActiveRecord::Migration
-  def self.up
-    change_column :backlogs, :name,  :string, :limit => 64, :null => false
-  end
-  
-  def self.down
-    execute "UPDATE backlogs SET name = SUBSTR(name, 0, 33)"
-    change_column :backlogs, :name,  :string, :limit => 32, :null => false
-  end
-end

data/db/migrate/018_create_groups.rb

@@ -1,118 +0,0 @@
-class CreateGroups < ActiveRecord::Migration
-  def self.up
-    create_table :parties do |t|
-      t.column :type, :string
-    end
-    
-    create_table :groups, :primary_key => :party_id do |t|
-      t.column :name, :string, :null => false
-    end
-    
-    rename_column :users, :id, :party_id
-    
-    execute "INSERT INTO parties (id, type) SELECT party_id, 'User' FROM users"
-    if ActiveRecord::Base.connection.adapter_name.downcase == "postgresql"
-      ActiveRecord::Base.connection.execute "select setval('parties_id_seq', (select max(id) from parties));"
-    end
-    add_foreign_key :users, :party_id, :parties, :id
-    
-    create_table :groups_users, :id => false do |t|
-      t.column :group_id, :integer, :null => false, :references => nil
-      t.column :user_id, :integer, :null => false, :references => nil
-    end
-    
-    add_foreign_key :groups_users, :group_id, :groups, :party_id
-    add_foreign_key :groups_users, :user_id, :users, :party_id
-    
-    add_index :groups_users, ["group_id", "user_id"], :unique => true
-    
-    add_column :periods, :party_id, :integer
-    add_index :periods, ["party_id", "position"], :unique => true
-    
-    add_column :tasks, :backlog_id, :integer
-    
-    load_classes
-    
-    Backlog.find(:all).each do |b|
-      next if b.periods.empty?
-      group = Group.create! :name => (b.name + 'Group')
-      b.periods.each do |p|
-        p.party_id = group.id
-        p.save!
-        p.tasks.each {|t| t.backlog = b; t.save!}
-      end
-      users = b.periods.map {|p| p.tasks.map {|t| t.estimates.map{|e| e.user} + t.works.map{|w| w.user}}}.flatten.compact.uniq
-      users.each do |u|
-        execute "INSERT INTO groups_users (group_id, user_id) VALUES (#{group.id}, #{u.id})"
-      end
-    end
-    
-    remove_column :periods, :backlog_id
-  end
-  
-  def self.down
-    add_column :periods, :backlog_id, :integer
-    load_classes
-    Period.find(:all).each do |p|
-      if first_task = p.tasks.first
-        p.backlog_id = first_task.backlog_id
-        p.save!
-      end
-    end
-    change_column :periods, :backlog_id, :integer, :null => false    
-    
-    remove_column :tasks, :backlog_id
-    remove_column :periods, :party_id
-    drop_table :groups_users
-
-    User.foreign_keys.select {|fk| fk.references_table_name == 'parties'}.each do |fk|
-      remove_foreign_key :users, fk.name
-    end
-    
-    rename_column :users, :party_id, :id
-    drop_table :groups
-    drop_table :parties
-  end
-  
-  def self.load_classes
-    class_eval <<EOF
-  class Party < ActiveRecord::Base
-  end
-  
-  class User < Party
-    class_table_inheritance
-  end
-  
-  class Group < Party
-    class_table_inheritance
-    has_and_belongs_to_many :users, :class_name => 'CreateGroups::User'
-  end
-  
-  class Backlog < ActiveRecord::Base
-    has_many :periods
-  end
-  
-  class Period < ActiveRecord::Base
-    #  belongs_to :backlog
-    #  belongs_to :party
-    has_many :tasks
-  end
-  
-  class Estimate < ActiveRecord::Base
-    belongs_to :user
-  end
-  
-  class Work < ActiveRecord::Base
-    belongs_to :user
-  end
-  
-  class Task < ActiveRecord::Base
-    belongs_to :backlog
-    belongs_to :period
-    has_many :estimates
-    has_many :works
-  end
-EOF
-    
-  end
-end

data/db/migrate/019_remove_unique_index_for_period_position.rb

@@ -1,9 +0,0 @@
-class RemoveUniqueIndexForPeriodPosition < ActiveRecord::Migration
-  def self.up
-    remove_index "periods", ["party_id", "position"]
-  end
-
-  def self.down
-    add_index "periods", ["position", "party_id"], :name => "index_periods_on_party_id_and_position", :unique => true
-  end
-end

data/db/migrate/020_create_task_files.rb

@@ -1,17 +0,0 @@
-class CreateTaskFiles < ActiveRecord::Migration
-  def self.up
-    add_column :tasks, :notes, :text
-
-    create_table :task_files do |t|
-      t.column :task_id, :integer, :null => false
-      t.column :name, :string, :limit => 64, :null => false
-      t.column :content_type, :string, :null => false
-      t.column :content_data, :binary, :null => false
-    end
-  end
-
-  def self.down
-    drop_table :task_files
-    remove_column :tasks, :notes
-  end
-end

data/db/migrate/021_create_work_accounts.rb

@@ -1,111 +0,0 @@
-class CreateWorkAccounts < ActiveRecord::Migration
-  def self.up
-    create_table :work_accounts do |t|
-      t.column :name, :string, :limit => 64, :null => false
-      t.column :track_times, :boolean
-      t.column :invoice_code, :string, :size => 16
-    end
-    
-    create_table :customers do |t|
-      t.column :name, :string, :limit => 64, :null => false
-    end
-    
-    add_column :backlogs, :work_account_id, :integer
-    add_column :tasks, :work_account_id, :integer
-    add_column :works, :work_account_id, :integer
-    add_column :backlogs, :customer_id, :integer
-    add_column :tasks, :customer_id, :integer
-    add_column :works, :customer_id, :integer
-    add_column :works, :description, :string
-    change_column_null :works, :task_id, :integer, true
-    
-    load_classes
-    
-    Backlog.find(:all, :conditions => 'invoice_code IS NOT NULL').each do |backlog|
-      work_account = WorkAccount.find_by_invoice_code(backlog.invoice_code)
-      if work_account.nil?
-        puts "Creating new work account: #{backlog.name}"
-        work_account = WorkAccount.create!(:name => backlog.name, :invoice_code => backlog.invoice_code, :track_times => backlog.track_times)
-      end
-      if backlog.work_account.nil?
-        backlog.work_account = work_account
-        puts "Updating backlog with work account: #{work_account.name}"
-        backlog.save!
-      end
-      backlog.tasks.each do |task|
-        task.works.each do |work|
-          if work.work_account.nil?
-            puts "Updating work with work account: #{work_account.name}"
-            work.work_account = work_account
-            work.save!
-          end
-        end
-      end
-    end
-    
-    change_column :works, :work_account_id, :integer, :null => false
-    
-    Task.find(:all, :conditions => 'customer IS NOT NULL AND LENGTH(customer) > 0').each do |task|
-      customer = Customer.find_by_name(task.attributes['customer'])
-      if customer.nil?
-        puts "Creating new customer: #{task.attributes['customer']}"
-        customer = Customer.create!(:name => task.attributes['customer'])
-      end
-      if task.customer.nil?
-        task.customer = customer
-        puts "Updating task with customer: #{customer.name}"
-        task.save!
-      end
-      task.works.each do |work|
-        if work.customer.nil?
-          puts "Updating work with customer: #{customer.name}"
-          work.customer = customer
-          work.save!
-        end
-      end
-    end
-    
-    remove_column :backlogs, :invoice_code
-    remove_column :backlogs, :track_times
-    remove_column :tasks, :customer
-    
-    create_table :configurations do |t|
-      t.column :time_keeper, :boolean
-    end
-    
-  end
-  
-  def self.down
-    raise "Not implemented, yet"
-    drop_table :configurations
-    drop_table :customers
-    drop_table :work_accounts
-  end
-  
-  def self.load_classes
-    class_eval <<EOF
-  class WorkAccount < ActiveRecord::Base
-  end
-  
-  class Customer < ActiveRecord::Base
-  end
-  
-  class Backlog < ActiveRecord::Base
-    belongs_to :work_account
-    has_many :tasks
-  end
-  
-  class Work < ActiveRecord::Base
-    belongs_to :work_account
-  end
-  
-  class Task < ActiveRecord::Base
-    belongs_to :customer
-    has_many :works
-  end
-  
-EOF
-    
-  end
-  
-end

data/db/migrate/022_remove_track_done_flag.rb

@@ -1,9 +0,0 @@
-class RemoveTrackDoneFlag < ActiveRecord::Migration
-  def self.up
-    remove_column :backlogs, :track_done
-  end
-
-  def self.down
-    add_column :backlogs, :track_done, :boolean
-  end
-end

data/db/migrate/023_add_indices_for_burn_down_chart.rb

@@ -1,13 +0,0 @@
-class AddIndicesForBurnDownChart < ActiveRecord::Migration
-  def self.up
-    add_index :tasks, :parent_id
-    add_index :estimates, [:task_id, :created_at]
-    add_index :works, [:task_id, :completed_at]
-  end
-
-  def self.down
-    remove_index :works, [:task_id, :completed_at]
-    remove_index :estimates, [:task_id, :created_at]
-    remove_index :tasks, :parent_id
-  end
-end

data/db/migrate/024_add_sprint_option.rb

@@ -1,10 +0,0 @@
-class AddSprintOption < ActiveRecord::Migration
-  def self.up
-    add_column :backlogs, :enable_periods, :boolean
-    execute("UPDATE backlogs SET enable_periods = TRUE")
-  end
-
-  def self.down
-    remove_column :backlogs, :enable_periods
-  end
-end

data/db/migrate/025_add_simple_auditing_of_tasks.rb

@@ -1,11 +0,0 @@
-class AddSimpleAuditingOfTasks < ActiveRecord::Migration
-  def self.up
-    add_column :tasks, :created_by, :integer, :references => [:users, :party_id]
-    add_column :tasks, :updated_by, :integer, :references => [:users, :party_id]
-  end
-
-  def self.down
-    remove_column :tasks, :updated_by
-    remove_column :tasks, :created_by
-  end
-end

data/db/migrate/026_add_users_to_tasks.rb

@@ -1,14 +0,0 @@
-class AddUsersToTasks < ActiveRecord::Migration
-  def self.up
-    add_column :tasks, :updated_at, :timestamp
-    create_table :tasks_users, :id => false do |t|
-      t.column :task_id, :integer, :null => false
-      t.column :user_id, :integer, :null => false, :references => [:users, :party_id]
-    end
-  end
-
-  def self.down
-    drop_table :tasks_users
-    remove_column :tasks, :updated_at
-  end
-end

data/db/migrate/027_create_work_locks.rb

@@ -1,25 +0,0 @@
-class CreateWorkLocks < ActiveRecord::Migration
-  def self.up
-    create_table :work_locks do |t|
-      t.column :user_id, :integer, :null => false, :references => [:users, :party_id]
-      t.column :start_on, :date, :null => false
-      t.column :end_on, :date, :null => false
-    end
-    
-    create_table :work_lock_subscriptions, :id => false do |t|
-      t.column :subscriber_user_id, :integer, :null => false, :references => [:users, :party_id]
-      t.column :work_account_id, :integer, :null => false
-    end
-
-    create_table :user_work_lock_subscriptions, :id => false do |t|
-      t.column :subscriber_user_id, :integer, :null => false, :references => [:users, :party_id]
-      t.column :user_id, :integer, :null => false, :references => [:users, :party_id]
-    end
-  end
-
-  def self.down
-    drop_table :user_work_lock_subscriptions
-    drop_table :work_lock_subscriptions
-    drop_table :work_locks
-  end
-end

data/db/migrate/028_create_absences.rb

@@ -1,34 +0,0 @@
-class CreateAbsences < ActiveRecord::Migration
-  def self.up
-    create_table :absences do |t|
-      t.column :user_id, :integer, :null => false, :references => [:users, :party_id]
-      t.column :on, :date, :null => false
-      t.column :reason, :string, :null => false
-    end
-    
-    add_column :works, :started_on, :date, :null => true
-    add_column :works, :start_time, :time, :null => true
-    Work.find(:all).each do |w|
-      w.started_on = (w.started_at || w.completed_at).to_date
-      w.start_time = w.started_at && w.started_at.time_of_day
-      w.save!
-    end
-    change_column_null :works, :started_on, :date, false
-    remove_column :works, :started_at
-  end
-  
-  def self.down
-    add_column :works, :started_at, :timestamp
-    Work.find(:all).each do |w|
-      w.started_at = w.start_time && w.start_time.on(w.started_on)
-      w.save!
-    end
-    remove_column :works, :started_on
-    remove_column :works, :start_time
-    drop_table :absences
-  end
-  
-  class Work < ActiveRecord::Base
-  end
-  
-end

data/db/migrate/029_add_work_comments.rb

@@ -1,9 +0,0 @@
-class AddWorkComments < ActiveRecord::Migration
-  def self.up
-    add_column :works, :notes, :text
-  end
-
-  def self.down
-    remove_column :works, :notes
-  end
-end

data/db/migrate/030_create_public_holidays.rb

@@ -1,11 +0,0 @@
-class CreatePublicHolidays < ActiveRecord::Migration
-  def self.up
-    create_table :public_holidays do |t|
-      t.column :on, :date, :null => false
-    end
-  end
-
-  def self.down
-    drop_table :public_holidays
-  end
-end

data/db/migrate/031_expand_work_done_precision.rb

@@ -1,9 +0,0 @@
-class ExpandWorkDonePrecision < ActiveRecord::Migration
-  def self.up
-    change_column :works, :hours, :decimal, :precision => 6, :scale => 3, :null => false, :default => 0
-  end
-
-  def self.down
-    change_column :works, :hours, :decimal, :precision => 6, :scale => 2, :null => false, :default => 0
-  end
-end

data/db/migrate/20100720124707_merge_work_account_into_backlog.rb

@@ -1,74 +0,0 @@
-class MergeWorkAccountIntoBacklog < ActiveRecord::Migration
-  def self.up
-    add_column :backlogs, :track_times, :boolean
-    add_column :works, :backlog_id, :integer
-    add_column :work_lock_subscriptions, :backlog_id, :integer
-    
-    load_classes
-    
-    work_account_to_backlog_map = {}
-    backlog_to_work_acountmap = {}
-    
-    work_accounts = WorkAccount.all(:include => :backlogs)
-    work_accounts.each{|wa| raise "Data errror" unless wa.backlogs.size == 1}
-    
-    backlogs = Backlog.all(:include => :work_account)
-    faulty_backlogs = backlogs.select{|bl| bl.work_account.nil?}
-    raise "Work account missing for: #{faulty_backlogs.map{|bl| bl.name}.join(', ')}" if faulty_backlogs.size > 0 
-    backlogs.each{|bl| work_account_to_backlog_map[bl.work_account_id] = bl ; backlog_to_work_acountmap[bl.id] = bl.work_account}
-    
-    backlogs.each{|bl| bl.update_attributes! :track_times => backlog_to_work_acountmap[bl.id].track_times || false}
-    change_column_null :backlogs, :track_times, false
-    
-    Work.all.each{|w| w.update_attributes! :backlog_id => work_account_to_backlog_map[w.work_account.id].id || raise("Missing backlog for work account #{w.id} #{w.work_account.name} #{w.work_account.id}")}
-    change_column_null :works, :backlog_id, false
-    
-    work_accounts.each{|wa| execute "UPDATE work_lock_subscriptions SET backlog_id = #{work_account_to_backlog_map[wa.id].id} WHERE work_account_id = #{wa.id}"}
-    change_column_null :work_lock_subscriptions, :backlog_id, false
-    
-    remove_column :backlogs, :work_account_id
-    remove_column :tasks, :work_account_id
-    remove_column :works, :work_account_id
-    remove_column :work_lock_subscriptions, :work_account_id
-  end
-  
-  def self.down
-    raise "Not implemented, yet."
-  end
-  
-  def self.load_classes
-    class_eval <<-EOF
-      class WorkAccount < ActiveRecord::Base
-        has_many :backlogs
-      end
-
-      class Backlog < ActiveRecord::Base
-        belongs_to :work_account
-      end
-
-      class Work < ActiveRecord::Base
-        belongs_to :task
-        belongs_to :work_account
-  
-        alias_method :old_work_account, :work_account
-        def work_account
-          self.old_work_account || (task && task.work_account)
-        end
-      end
-      
-      # class WorkLockSubscription < ActiveRecord::Base ; end
-
-      class Task < ActiveRecord::Base
-        belongs_to :backlog
-        belongs_to :work_account
-        acts_as_tree :order => 'position'
-      
-        alias_method :old_work_account, :work_account
-        def work_account
-          self.old_work_account || (parent ? parent.work_account : backlog.work_account)
-        end
-      end
-    EOF
-  end
-  
-end