backlog 0.0.4 → 0.0.5

data/db/schema.rb

@@ -2,7 +2,7 @@
 # migrations feature of ActiveRecord to incrementally modify your database, and
 # then regenerate this schema definition.
 
-ActiveRecord::Schema.define(:version => 17) do
+ActiveRecord::Schema.define(:version => 18) do
 
   create_table "backlogs", :force => true do |t|
     t.string  "name",            :limit => 64,                    :null => false
@@ -22,13 +22,30 @@ ActiveRecord::Schema.define(:version => 17) do
     t.integer  "user_id"
   end
 
+  create_table "groups", :primary_key => "party_id", :force => true do |t|
+    t.string "name", :null => false
+  end
+
+  create_table "groups_users", :id => false, :force => true do |t|
+    t.integer "group_id", :null => false
+    t.integer "user_id",  :null => false
+  end
+
+  add_index "groups_users", ["group_id", "user_id"], :name => "index_groups_users_on_group_id_and_user_id", :unique => true
+
+  create_table "parties", :force => true do |t|
+    t.string "type"
+  end
+
   create_table "periods", :force => true do |t|
-    t.integer "backlog_id", :null => false
-    t.integer "position",   :null => false
-    t.date    "start_on",   :null => false
-    t.date    "end_on",     :null => false
+    t.integer "position", :null => false
+    t.date    "start_on", :null => false
+    t.date    "end_on",   :null => false
+    t.integer "party_id"
   end
 
+  add_index "periods", ["position", "party_id"], :name => "index_periods_on_party_id_and_position", :unique => true
+
   create_table "tasks", :force => true do |t|
     t.integer  "position"
     t.string   "description",      :limit => 80,                                                :null => false
@@ -40,9 +57,10 @@ ActiveRecord::Schema.define(:version => 17) do
     t.string   "resolution",       :limit => 16
     t.integer  "previous_task_id"
     t.string   "customer",         :limit => 64
+    t.integer  "backlog_id"
   end
 
-  create_table "users", :force => true do |t|
+  create_table "users", :primary_key => "party_id", :force => true do |t|
     t.string   "login",           :limit => 80,                    :null => false
     t.string   "salted_password", :limit => 40,                    :null => false
     t.string   "email",           :limit => 60,                    :null => false
@@ -66,27 +84,69 @@ ActiveRecord::Schema.define(:version => 17) do
   end
 
   add_foreign_key_constraint "estimates", "task_id", "tasks", "id", :name => "estimates_task_id_fkey", :on_update => nil, :on_delete => nil
-  add_foreign_key_constraint "estimates", "user_id", "users", "id", :name => "estimates_user_id_fkey", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "estimates", "user_id", "users", "party_id", :name => "estimates_user_id_fkey", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "estimates", "task_id", "tasks", "id", :name => "estimates_task_id_fkey1", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "estimates", "user_id", "users", "party_id", :name => "estimates_user_id_fkey1", :on_update => nil, :on_delete => nil
+
+  add_foreign_key_constraint "groups", "party_id", "parties", "id", :name => "groups_party_id_fkey", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "groups", "party_id", "parties", "id", :name => "groups_party_id_fkey1", :on_update => nil, :on_delete => nil
+
+  add_foreign_key_constraint "groups_users", "group_id", "groups", "party_id", :name => "groups_users_group_id_fkey", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "groups_users", "user_id", "users", "party_id", :name => "groups_users_user_id_fkey", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "groups_users", "group_id", "groups", "party_id", :name => "groups_users_group_id_fkey1", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "groups_users", "user_id", "users", "party_id", :name => "groups_users_user_id_fkey1", :on_update => nil, :on_delete => nil
 
-  add_foreign_key_constraint "periods", "backlog_id", "backlogs", "id", :name => "periods_backlog_id_fkey", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "periods", "party_id", "parties", "id", :name => "periods_party_id_fkey", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "periods", "party_id", "parties", "id", :name => "periods_party_id_fkey1", :on_update => nil, :on_delete => nil
 
   add_foreign_key_constraint "tasks", "period_id", "periods", "id", :name => "tasks_period_id_fkey", :on_update => nil, :on_delete => nil
   add_foreign_key_constraint "tasks", "parent_id", "tasks", "id", :name => "tasks_parent_id_fkey", :on_update => nil, :on_delete => nil
   add_foreign_key_constraint "tasks", "previous_task_id", "tasks", "id", :name => "tasks_previous_task_id_fkey", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "tasks", "backlog_id", "backlogs", "id", :name => "tasks_backlog_id_fkey", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "tasks", "period_id", "periods", "id", :name => "tasks_period_id_fkey1", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "tasks", "parent_id", "tasks", "id", :name => "tasks_parent_id_fkey1", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "tasks", "previous_task_id", "tasks", "id", :name => "tasks_previous_task_id_fkey1", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "tasks", "backlog_id", "backlogs", "id", :name => "tasks_backlog_id_fkey1", :on_update => nil, :on_delete => nil
+
+  add_foreign_key_constraint "users", "party_id", "parties", "id", :name => "users_party_id_fkey", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "users", "party_id", "parties", "id", :name => "users_party_id_fkey1", :on_update => nil, :on_delete => nil
 
   add_foreign_key_constraint "works", "task_id", "tasks", "id", :name => "works_task_id_fkey", :on_update => nil, :on_delete => nil
-  add_foreign_key_constraint "works", "user_id", "users", "id", :name => "works_user_id_fkey", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "works", "user_id", "users", "party_id", :name => "works_user_id_fkey", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "works", "task_id", "tasks", "id", :name => "works_task_id_fkey1", :on_update => nil, :on_delete => nil
+  add_foreign_key_constraint "works", "user_id", "users", "party_id", :name => "works_user_id_fkey1", :on_update => nil, :on_delete => nil
 
   add_foreign_key "estimates", ["task_id"], "tasks", ["id"]
-  add_foreign_key "estimates", ["user_id"], "users", ["id"]
+  add_foreign_key "estimates", ["user_id"], "users", ["party_id"]
+  add_foreign_key "estimates", ["task_id"], "tasks", ["id"]
+  add_foreign_key "estimates", ["user_id"], "users", ["party_id"]
+
+  add_foreign_key "groups", ["party_id"], "parties", ["id"]
+  add_foreign_key "groups", ["party_id"], "parties", ["id"]
 
-  add_foreign_key "periods", ["backlog_id"], "backlogs", ["id"]
+  add_foreign_key "groups_users", ["group_id"], "groups", ["party_id"]
+  add_foreign_key "groups_users", ["user_id"], "users", ["party_id"]
+  add_foreign_key "groups_users", ["group_id"], "groups", ["party_id"]
+  add_foreign_key "groups_users", ["user_id"], "users", ["party_id"]
+
+  add_foreign_key "periods", ["party_id"], "parties", ["id"]
+  add_foreign_key "periods", ["party_id"], "parties", ["id"]
 
   add_foreign_key "tasks", ["period_id"], "periods", ["id"]
   add_foreign_key "tasks", ["parent_id"], "tasks", ["id"]
   add_foreign_key "tasks", ["previous_task_id"], "tasks", ["id"]
+  add_foreign_key "tasks", ["backlog_id"], "backlogs", ["id"]
+  add_foreign_key "tasks", ["period_id"], "periods", ["id"]
+  add_foreign_key "tasks", ["parent_id"], "tasks", ["id"]
+  add_foreign_key "tasks", ["previous_task_id"], "tasks", ["id"]
+  add_foreign_key "tasks", ["backlog_id"], "backlogs", ["id"]
 
+  add_foreign_key "users", ["party_id"], "parties", ["id"]
+  add_foreign_key "users", ["party_id"], "parties", ["id"]
+
+  add_foreign_key "works", ["task_id"], "tasks", ["id"]
+  add_foreign_key "works", ["user_id"], "users", ["party_id"]
   add_foreign_key "works", ["task_id"], "tasks", ["id"]
-  add_foreign_key "works", ["user_id"], "users", ["id"]
+  add_foreign_key "works", ["user_id"], "users", ["party_id"]
 
 end

data/lang/en.yaml

@@ -24,14 +24,19 @@ enable_subtasks: Enable Subtasks
 enable_users: Enable users
 end_on: End on
 end_work: Stop
+estimate: Estimate
 friday: Friday
+group: Group
 home: Home
+hours: Hours
 invoice: Invoice
 invoice_short: Inv.
 left: Left
 listing_works: Recorded work
 log_in: Log in
+log_out: Log out
 main_backlog: Main Backlog
+members: Members
 monday: Monday
 move_to_bottom: Move task to bottom of list
 move_to_next_period: Move task to next period
@@ -53,6 +58,7 @@ resolution: Resolution
 right: Right
 saturday: Saturday
 save: Save
+select: Select
 shortcuts: Shortcuts
 specify: Specify
 start: Start
@@ -73,3 +79,4 @@ up: Up
 user: User
 wednesday: Wednesday
 week: Week
+work: Work

data/lang/no.yaml

@@ -24,14 +24,19 @@ enable_subtasks: Tillat underoppgaver
 enable_users: Tillat brukere
 end_on: Avslutt på
 end_work: Stopp
+estimate: Estimat
 friday: Fredag
+group: Gruppe
 home: Hjem
+hours: Timer
 invoice: Fakturerbart
 invoice_short: Fakt
 left: Venstre
 listing_works: Registrert arbeid
 log_in: Log inn
+log_out: Log ut
 main_backlog: Hovedliste
+members: Medlemmer
 monday: Mandag
 move_to_bottom: Flytt oppgaven til slutten av listen
 move_to_next_period: Flytt oppgaven til nexte periode
@@ -53,6 +58,7 @@ resolution: Avslutningsmåte
 right: Høyre
 saturday: Lørdag
 save: Lagre
+select: Velg
 shortcuts: Knapper
 specify: Spesifisèr
 start: Start
@@ -72,3 +78,4 @@ up: Opp
 user: Bruker
 wednesday: Onsdag
 week: Uke
+work: Arbeid

data/lib/big_decimal_yaml_fix.rb

@@ -0,0 +1,27 @@
+require 'yaml'
+require 'bigdecimal'
+require 'rubygems'
+require 'active_support'
+
+class BigDecimal
+  yaml_as "tag:yaml.org,2002:float"
+  def to_yaml( opts = {} )
+    YAML::quick_emit( nil, opts ) do |out|
+            # This emits the number without any scientific notation. 
+            # I prefer it to using self.to_f.to_s, which would loose precision.
+            #
+            # Note that YAML allows that when reconsituting floats 
+            # to native types, some precision may get lost. 
+            # There is no full precision real YAML tag that I am aware of.
+            str = self.to_s
+            if str == "Infinity"
+                str = ".Inf"
+            elsif str == "-Infinity"
+                str = "-.Inf"
+            elsif str == "NaN"
+                str = ".NaN"
+            end
+            out.scalar( "tag:yaml.org,2002:float", str, :plain )
+        end
+  end
+end

data/lib/class_table_inheritance.rb

@@ -0,0 +1,163 @@
+class ActiveRecord::Base
+  class_inheritable_array :default_eager_loading
+  
+  class << self
+    alias_method :has_one_without_cti, :has_one
+    
+    def find_with_default_eager_loading(*params)
+      if default_eager_loading
+        if params.last.is_a?(Hash)
+          opts = params.last
+        else
+          opts = {}
+          params.push(opts)
+        end
+        opts[:include] ||= []
+        opts[:include] = [opts[:include]] unless opts[:include].is_a?(Array)
+        opts[:include] += default_eager_loading
+      end
+      find_without_default_eager_loading(*params)
+    end
+    
+    alias_method_chain :find, :default_eager_loading
+    
+    def class_table_inheritance(options = {})
+      table_name = options[:subclass_table] || name.demodulize.tableize
+      primary_key_name = options[:subclass_foreign_key] || "#{superclass.name.demodulize.underscore}_id"
+      
+      has_extra_columns_from(
+                             :table => table_name, :foreign_key => primary_key_name,
+                             :proxy_class_name => 'ExtraColumns',
+      :proxy_class_belongs_to => self.name,
+      :delegate_new_associations => true,
+      :save_before_superclass_callbacks => true
+      )
+    end
+    
+    def has_extra_columns_from(options, &block)
+      table_name = options[:table]
+      primary_key_name = options[:foreign_key] || "#{name.demodulize.underscore}_id"
+      
+      proxy_class_name = options[:proxy_class_name] || "ExtraColumnsFor#{table_name.camelize}"
+      proxy_class_namespace = (options[:proxy_class_namespace] || name).constantize
+      proxy_symbol = "extra_columns_for_#{table_name}".to_sym
+      
+      proxy_class = proxy_class_namespace.const_get(proxy_class_name) rescue nil
+      unless proxy_class
+        proxy_class = proxy_class_namespace.const_set(proxy_class_name, Class.new(ActiveRecord::Base))    
+        proxy_class.class_eval do
+          set_table_name table_name
+          set_primary_key primary_key_name
+          def self.reloadable?; false; end
+        end
+        proxy_class.class_eval(&block) if block_given?
+      end
+      
+      has_one_without_cti proxy_symbol, :class_name => proxy_class.name, :foreign_key => primary_key_name, :dependent => true
+      
+      if options[:save_before_superclass_callbacks] || true
+        # We need the after_save filter for this association to run /before/ any other after_save's already registered on a superclass,
+        # and before any after_creates or after_updates. This calls for some hackery:
+        proxy_save_callback = @inheritable_attributes[:after_save].pop
+        @inheritable_attributes[:after_create] ||= []
+        @inheritable_attributes[:after_create].unshift(proxy_save_callback)
+        @inheritable_attributes[:after_update] ||= []
+        @inheritable_attributes[:after_update].unshift(proxy_save_callback)
+      end
+      
+      # adds this to the class-inheritable array of default eager loads:
+      self.default_eager_loading = [proxy_symbol] unless options[:default_eager_loading] == false
+      
+      class_eval <<-EOV
+        alias_method :#{proxy_symbol}_old, :#{proxy_symbol}
+        def #{proxy_symbol}
+          #{proxy_symbol}_old or self.#{proxy_symbol} = #{proxy_class.name}.new
+        end
+        def save(*args)
+          self.#{proxy_symbol} ||= #{proxy_class.name}.new
+          super
+        end
+        # this doesn't happen automatically on update, so we'll make it:
+        after_update {|record| record.#{proxy_symbol}.save }
+        
+        alias_method :write_attribute_super, :write_attribute
+        def write_attribute(attr_name, attr_value)
+          if self.class.columns.find {|c| c.name == attr_name}
+            write_attribute_super(attr_name, attr_value)
+          else
+            self.#{proxy_symbol}.write_attribute(attr_name, attr_value)
+          end
+        end
+          
+        alias_method :old_attributes, :attributes
+        def attributes
+          all_attributes = old_attributes.update(self.#{proxy_symbol}.attributes)
+          all_attributes.delete(#{proxy_class_name}.primary_key) if self.class.primary_key != #{proxy_class_name}.primary_key
+          all_attributes
+        end
+
+        class << self
+          alias_method :method_missing_super, :method_missing
+          def method_missing(method_symbol, *parameters)
+            if method_symbol.to_s =~ /^find_by_(.+)/
+              attributes = $1.split('_and_')
+              super_attributes = attributes & columns.map {|c| c.name}
+              sub_attributes = attributes - super_attributes
+              if super_attributes.size > 0
+                # TODO (uwe): Only use super attributes first
+                # then filter by sub_attributes
+                method_missing_super(method_symbol, parameters)
+              else
+                #{proxy_class_name}.method_missing(method_symbol, parameters)
+              end
+            else
+              method_missing_super(method_symbol, parameters)
+            end
+          end
+        end
+      EOV
+      
+      delegate_methods = proxy_class.column_names
+      delegate_methods += proxy_class.column_names.map {|name| "#{name}=".to_sym }
+      delegate_methods += proxy_class.column_names.map {|name| "#{name}?".to_sym }
+      proxy_class.reflect_on_all_associations.each do |reflection|
+        delegate_methods += case reflection.macro
+        when :has_many, :has_and_belongs_to_many
+          [reflection.name, "#{reflection.name}=".to_sym, "#{reflection.name.to_s.singularize}_ids=".to_sym]
+        when :has_one
+          [reflection.name, "#{reflection.name}=".to_sym, "build_#{reflection.name}".to_sym, "create_#{reflection.name}".to_sym]
+        when :belongs_to
+          [reflection.name, "#{reflection.name}=".to_sym, "#{reflection.name}?".to_sym, "build_#{reflection.name}".to_sym, "create_#{reflection.name}".to_sym]
+        end
+      end
+      delegate *(delegate_methods << {:to => proxy_symbol})
+      
+      proxy_class.belongs_to(:base, :class_name => options[:proxy_class_belongs_to], :foreign_key => primary_key_name) if options[:proxy_class_belongs_to]
+      
+      if options[:delegate_new_associations]
+        class_eval <<-EOV
+          # associations on this subclass get added to the proxy class, and then the relevant methods delegated to the proxy object
+          def self.belongs_to(name, *params)
+            ExtraColumns.belongs_to(name, *params)
+            delegate name, "\#{name}=".to_sym, "\#{name}?".to_sym, "build_\#{name}".to_sym, "create_\#{name}".to_sym, :to => :#{proxy_symbol}
+          end
+
+          def self.has_one(name, *params)
+            ExtraColumns.has_one(name, *params)
+            delegate name, "\#{name}=".to_sym, "build_\#{name}".to_sym, "create_\#{name}".to_sym, :to => :#{proxy_symbol}
+          end
+
+          def self.has_many(name, *params)
+            ExtraColumns.has_many(name, *params)
+            delegate name, "\#{name}=".to_sym, "\#{name.to_s.singularize}_ids=".to_sym, :to => :#{proxy_symbol}
+          end
+
+          def self.has_and_belongs_to_many(name, *params)
+            ExtraColumns.has_and_belongs_to_many(name, *params)
+            delegate name, "\#{name}=".to_sym, "\#{name.to_s.singularize}_ids=".to_sym, :to => :#{proxy_symbol}
+          end
+        EOV
+      end
+    end
+  end
+end

data/lib/tasks/backup.rake

@@ -0,0 +1,92 @@
+# Original file by Tobias Luetke, found on
+#   http://blog.leetsoft.com/2006/5/29/easy-migration-between-databases
+#
+# set_sequences task by tnb@thenakedbrain.com
+#
+namespace :db do
+  namespace :backup do
+    
+    def entity_table?(table_name)
+      columns = ActiveRecord::Base.connection.columns(table_name).map{|column|column.name}
+      columns.include?('id') || columns.include?('party_id')
+    end
+    
+    def interesting_tables
+      tables = ActiveRecord::Base.connection.tables.sort.reject do |tbl|
+        ['schema_info', 'sessions', 'logged_exceptions'].include?(tbl)
+      end
+      tables.select do |tbl|
+        entity_table?(tbl)
+      end
+    end
+    
+    def load_table tbl, loaded_tables
+      return if loaded_tables.include? tbl
+      loaded_tables << tbl
+      klass = tbl.classify.constantize
+      klass.foreign_keys.each do |f_key|
+        load_table f_key.references_table_name, loaded_tables
+      end
+      ActiveRecord::Base.transaction do 
+        puts "Loading #{tbl}..."
+        if ActiveRecord::Base.connection.adapter_name.downcase == 'postgresql'
+          ActiveRecord::Base.connection.execute "ALTER TABLE #{tbl} DISABLE TRIGGER ALL"
+        elsif ActiveRecord::Base.connection.adapter_name.downcase == 'mysql'
+          ActiveRecord::Base.connection.execute "SET FOREIGN_KEY_CHECKS=0"
+        end
+        YAML.load_file("#{tbl}.yml").each do |fixture|
+          klass.new(fixture).save_without_validation!
+        end
+        if ActiveRecord::Base.connection.adapter_name.downcase == "postgresql"
+          ActiveRecord::Base.connection.execute "ALTER TABLE #{tbl} ENABLE TRIGGER ALL"
+        elsif ActiveRecord::Base.connection.adapter_name.downcase == 'mysql'
+          ActiveRecord::Base.connection.execute "SET FOREIGN_KEY_CHECKS=1"
+        end
+      end
+    end
+    
+    desc "Dump entire db."
+    task :write => :environment do 
+      dir = RAILS_ROOT + "/db/backup"
+      FileUtils.mkdir_p(dir)
+      FileUtils.chdir(dir)
+      
+      interesting_tables.each do |tbl|
+        klass = tbl.classify.constantize
+        puts "Writing #{tbl}..."
+        entities = klass.find(:all)
+        if klass.column_names.include? 'type'
+          entities = entities.select {|e| e.type == klass}
+        end
+        File.open("#{tbl}.yml", 'w+') { |f| YAML.dump entities.collect(&:attributes), f }      
+      end
+    end
+    
+    task :read => [:environment, 'db:schema:load'] do 
+      dir = RAILS_ROOT + '/db/backup'
+      FileUtils.mkdir_p(dir)
+      FileUtils.chdir(dir)
+      
+      loaded_tables = []
+      
+      interesting_tables.each do |tbl|
+        load_table(tbl, loaded_tables)
+      end
+    end
+    
+    desc "Set postgresql sequence currval to highest id for each table"
+    task :set_sequences => :environment do
+      if ActiveRecord::Base.connection.adapter_name.downcase == "postgresql"
+        interesting_tables.each do |tbl|
+          if ActiveRecord::Base.connection.columns(tbl).map{|column|column.name}.include?('id')
+            puts "Setting sequence's currval to highest id for #{tbl}"
+            ActiveRecord::Base.connection.execute "select setval('#{tbl}_id_seq', (select max(id) from #{tbl}));"
+          end
+        end
+      else
+        puts "This operation only works for postgresql databases."
+      end
+    end
+    
+  end
+end