redmine_rate 0.2.0

data/lib/rate_conversion.rb

@@ -0,0 +1,16 @@
+class RateConversion
+  RoundTo = 10
+  
+  MemberRateDataFile = "#{RAILS_ROOT}/tmp/budget_member_rate_data.yml"
+  DeliverableDataFile = "#{RAILS_ROOT}/tmp/budget_deliverable_data.yml"
+  VendorInvoiceDataFile = "#{RAILS_ROOT}/tmp/billing_vendor_invoice_data.yml"
+
+  
+  def self.compare_values(pre, post, message)
+    pre = pre.to_f.round(RoundTo)
+    post = post.to_f.round(RoundTo)
+    
+    puts "ERROR: #{message} (pre: #{pre}, post: #{post})" unless pre == post
+    return pre == post
+  end
+end

data/lib/rate_memberships_hook.rb

@@ -0,0 +1,15 @@
+class RateMembershipsHook < Redmine::Hook::ViewListener
+  def view_users_memberships_table_header(context={})
+    return content_tag(:th, l(:rate_label_rate) + ' ' + l(:rate_label_currency))
+  end
+
+  def view_users_memberships_table_row(context={})
+    return context[:controller].send(:render_to_string, {
+                                       :partial => 'users/membership_rate',
+                                       :locals => {
+                                         :membership => context[:membership],
+                                         :user => context[:user]
+                                       }})
+                                                   
+  end
+end

data/lib/rate_project_hook.rb

@@ -0,0 +1,106 @@
+# Hooks to attach to the Redmine Projects.
+class RateProjectHook < Redmine::Hook::ViewListener
+  
+  def protect_against_forgery?
+    false
+  end
+  
+  # Renders an additional table header to the membership setting
+  #
+  # Context:
+  # * :project => Current project
+  #
+  def view_projects_settings_members_table_header(context ={ })
+    return '' unless (User.current.allowed_to?(:view_rate, context[:project]) || User.current.admin?)
+    return "<th>#{l(:rate_label_rate)} #{l(:rate_label_currency)}</td>"
+  end
+  
+  # Renders an AJAX from to update the member's billing rate
+  #
+  # Context:
+  # * :project => Current project
+  # * :member => Current Member record
+  #
+  # TODO: Move to a view
+  def view_projects_settings_members_table_row(context = { })
+    member = context[:member]
+    project = context[:project]
+
+    return '' unless (User.current.allowed_to?(:view_rate, project) || User.current.admin?)
+
+    if Object.const_defined? 'Group' # 0.8.x compatibility
+      # Groups cannot have a rate
+      return content_tag(:td,'') if member.principal.is_a? Group
+      rate = Rate.for(member.principal, project)
+    else
+      rate = Rate.for(member.user, project)
+    end
+
+    content = ''
+    
+    if rate.nil? || rate.default?
+      if rate && rate.default?
+        content << "<em>#{number_to_currency(rate.amount)}</em> "
+      end
+
+      if (User.current.admin?)
+
+      url = {
+        :controller => 'rates',
+        :action => 'create',
+        :method => :post,
+        :protocol => Setting.protocol,
+        :host => Setting.host_name
+      }
+      # Build a form_remote_tag by hand since this isn't in the scope of a controller
+      # and url_rewriter doesn't like that fact.
+      form = form_tag(url, :onsubmit => remote_function(:url => url,
+                                                        :host => Setting.host_name,
+                                                        :protocol => Setting.protocol,
+                                                        :form => true,
+                                                        :method => 'post',
+                                                        :return => 'false' )+ '; return false;')
+      
+      form << text_field(:rate, :amount)
+      form << hidden_field(:rate,:date_in_effect, :value => Date.today.to_s)
+      form << hidden_field(:rate, :project_id, :value => project.id)
+      form << hidden_field(:rate, :user_id, :value => member.user.id) 
+      form << hidden_field_tag("back_url", url_for(:controller => 'projects', :action => 'settings', :id => project, :tab => 'members', :protocol => Setting.protocol, :host => Setting.host_name))
+
+      form << submit_tag(l(:rate_label_set_rate), :class => "small")
+      form << "</form>"
+        
+      content << form
+      end
+    else
+      if (User.current.admin?)
+
+      content << content_tag(:strong, link_to(number_to_currency(rate.amount), { 
+                                                :controller => 'users',
+                                                :action => 'edit',
+                                                :id => member.user,
+                                                :tab => 'rates',
+                                                :protocol => Setting.protocol,
+                                                :host => Setting.host_name
+                                              }))
+      else
+        content << content_tag(:strong, number_to_currency(rate.amount))
+      end
+    end
+    return content_tag(:td, content, :align => 'left', :id => "rate_#{project.id}_#{member.user.id}" )
+  end
+
+  def model_project_copy_before_save(context = {})
+    source = context[:source_project]
+    destination = context[:destination_project]
+
+    Rate.find(:all, :conditions => {:project_id => source.id}).each do |source_rate|
+      destination_rate = Rate.new
+
+      destination_rate.attributes = source_rate.attributes.except("project_id")
+      destination_rate.project = destination
+      destination_rate.save # Need to save here because there is no relation on project to rate
+    end
+  end
+end
+

data/lib/rate_sort_helper_patch.rb

@@ -0,0 +1,102 @@
+module RateSortHelperPatch
+  def self.included(base) # :nodoc:
+    base.send(:include, InstanceMethods)
+  end
+  
+  module InstanceMethods
+    # Allows more parameters than the standard sort_header_tag
+    def rate_sort_header_tag(column, options = {})
+      caption = options.delete(:caption) || titleize(Inflector::humanize(column))
+      default_order = options.delete(:default_order) || 'asc'
+      options[:title]= l(:label_sort_by, "\"#{caption}\"") unless options[:title]
+      content_tag('th',
+                  rate_sort_link(column,
+                                 caption,
+                                 default_order,
+                                 { :method => options[:method], :update => options[:update], :user_id => options[:user_id] }),
+                  options)
+    end
+
+    # Allows more parameters than the standard sort_link and is hard coded to use
+    # the RatesController and to have an :method and :update options
+    def rate_sort_link(column, caption, default_order, options = { })
+      # 0.8.x compatibility
+      if SortHelper.const_defined? 'SortCriteria'
+        rate_sort_link_trunk_version(column, caption, default_order, options)
+      else
+        rate_sort_link_08_version(column, caption, default_order, options)
+      end
+    end
+
+    private
+    # Trunk version of sort_link.  Was modified in r2571 of Redmine
+    def rate_sort_link_trunk_version(column, caption, default_order, options = { })
+      css, order = nil, default_order
+    
+      if column.to_s == @sort_criteria.first_key
+        if @sort_criteria.first_asc?
+          css = 'sort asc'
+          order = 'desc'
+        else
+          css = 'sort desc'
+          order = 'asc'
+        end
+      end
+      caption = column.to_s.humanize unless caption
+
+      sort_options = { :sort => @sort_criteria.add(column.to_s, order).to_param }
+      # don't reuse params if filters are present
+      url_options = params.has_key?(:set_filter) ? sort_options : params.merge(sort_options)
+    
+      # Add project_id to url_options
+      url_options = url_options.merge(:project_id => params[:project_id]) if params.has_key?(:project_id)
+
+      ##### Hard code url to the Rates index
+      url_options[:controller] = 'rates'
+      url_options[:action] = 'index'
+      url_options[:user_id] ||= options[:user_id]
+      #####
+
+      
+      link_to_remote(caption,
+                     {:update => options[:update] || "content", :url => url_options, :method => options[:method] || :post},
+                     {:href => url_for(url_options),
+                       :class => css})
+    end
+
+    private
+    # 0.8.x branch of sort_link.
+    def rate_sort_link_08_version(column, caption, default_order, options = { })
+      key, order = session[@sort_name][:key], session[@sort_name][:order]
+      if key == column
+        if order.downcase == 'asc'
+          icon = 'sort_asc.png'
+          order = 'desc'
+        else
+          icon = 'sort_desc.png'
+          order = 'asc'
+        end
+      else
+        icon = nil
+        order = default_order
+      end
+      caption = titleize(Inflector::humanize(column)) unless caption
+      
+      sort_options = { :sort_key => column, :sort_order => order }
+      # don't reuse params if filters are present
+      url_options = params.has_key?(:set_filter) ? sort_options : params.merge(sort_options)
+      
+      ##### Hard code url to the Rates index
+      url_options[:controller] = 'rates'
+      url_options[:action] = 'index'
+      url_options[:user_id] ||= options[:user_id]
+      #####
+
+      link_to_remote(caption,
+                     {:update => options[:update] || "content", :url => url_options, :method => options[:method] || :post},
+                     {:href => url_for(url_options)}) +
+        (icon ? nbsp(2) + image_tag(icon) : '')
+    end
+    
+  end
+end

data/lib/rate_time_entry_patch.rb

@@ -0,0 +1,66 @@
+module RateTimeEntryPatch
+  def self.included(base) # :nodoc:
+    base.extend(ClassMethods)
+
+    base.send(:include, InstanceMethods)
+
+    # Same as typing in the class 
+    base.class_eval do
+      unloadable # Send unloadable so it will not be unloaded in development
+      belongs_to :rate
+
+      before_save :cost
+      
+    end
+
+  end
+  
+  module ClassMethods
+    # Updated the cached cost of all TimeEntries for user and project
+    def update_cost_cache(user, project=nil)
+      c = ARCondition.new
+      c << ["#{TimeEntry.table_name}.user_id = ?", user]
+      c << ["#{TimeEntry.table_name}.project_id = ?", project] if project
+      
+      TimeEntry.all(:conditions => c.conditions).each do |time_entry|
+        time_entry.save_cached_cost
+      end
+    end
+  end
+  
+  module InstanceMethods
+    # Returns the current cost of the TimeEntry based on it's rate and hours
+    #
+    # Is a read-through cache method
+    def cost
+      unless read_attribute(:cost)
+        if self.rate.nil?
+          amount = Rate.amount_for(self.user, self.project, self.spent_on.to_s)
+        else
+          amount = rate.amount
+        end
+
+        if amount.nil?
+          write_attribute(:cost, 0.0)
+        else
+          # Write the cost to the database for caching
+          update_attribute(:cost, amount.to_f * hours.to_f)
+        end
+      end
+
+      read_attribute(:cost)
+    end
+
+    def clear_cost_cache
+      write_attribute(:cost, nil)
+    end
+    
+    def save_cached_cost
+      clear_cost_cache
+      update_attribute(:cost, cost)
+    end
+    
+  end
+end
+
+

data/lib/rate_users_helper_patch.rb

@@ -0,0 +1,37 @@
+module RateUsersHelperPatch
+  def self.included(base) # :nodoc:
+    base.send(:include, InstanceMethods)
+    base.class_eval do
+      alias_method_chain :user_settings_tabs, :rate_tab
+    end
+  end
+  
+  module InstanceMethods
+    # Adds a rates tab to the user administration page
+    def user_settings_tabs_with_rate_tab
+      tabs = user_settings_tabs_without_rate_tab
+      tabs << { :name => 'rates', :partial => 'users/rates', :label => :rate_label_rate_history}
+      return tabs
+    end
+    
+    # Similar to +project_options_for_select+ but allows selecting the active value
+    def project_options_for_select_with_selected(projects, selected = nil)
+      options = content_tag('option', "--- #{l(:rate_label_default)} ---", :value => '')
+      projects_by_root = projects.group_by(&:root)
+      projects_by_root.keys.sort.each do |root|
+        root_selected = (root == selected) ? 'selected' : nil
+
+        options << content_tag('option', h(root.name), :value => root.id, :disabled => (!projects.include?(root)), :selected => root_selected)
+        projects_by_root[root].sort.each do |project|
+          next if project == root
+          child_selected = (project == selected) ? 'selected' : nil
+
+          options << content_tag('option', '&#187; ' + h(project.name), :value => project.id, :selected => child_selected)
+        end
+      end
+      options
+    end
+    
+  end
+end
+

data/lib/redmine_rate/hooks/plugin_timesheet_view_timesheets_report_header_tags_hook.rb

@@ -0,0 +1,11 @@
+module RedmineRate
+  module Hooks
+    class PluginTimesheetViewTimesheetsReportHeaderTagsHook < Redmine::Hook::ViewListener
+      def plugin_timesheet_view_timesheets_report_header_tags(context={})
+        return content_tag(:style,
+                           'tr.missing-rate td.cost { color: red; }',
+                           :type => 'text/css')
+      end
+    end
+  end
+end

data/lib/redmine_rate/hooks/plugin_timesheet_views_timesheet_group_header_hook.rb

@@ -0,0 +1,9 @@
+module RedmineRate
+  module Hooks
+    class PluginTimesheetViewsTimesheetGroupHeaderHook < Redmine::Hook::ViewListener
+      def plugin_timesheet_views_timesheet_group_header(context={})
+        return content_tag(:th, l(:rate_cost), :width => '8%')
+      end
+    end
+  end
+end

data/lib/redmine_rate/hooks/plugin_timesheet_views_timesheet_time_entry_hook.rb

@@ -0,0 +1,18 @@
+module RedmineRate
+  module Hooks
+    class PluginTimesheetViewsTimesheetTimeEntryHook < Redmine::Hook::ViewListener
+      include TimesheetHookHelper
+      
+      def plugin_timesheet_views_timesheet_time_entry(context={})
+        cost = cost_item(context[:time_entry])
+        if cost
+          td_cell(number_to_currency(cost))
+        else
+          td_cell('&nbsp;')
+        end
+
+      end
+
+    end
+  end
+end

data/lib/redmine_rate/hooks/plugin_timesheet_views_timesheet_time_entry_sum_hook.rb

@@ -0,0 +1,17 @@
+module RedmineRate
+  module Hooks
+    class PluginTimesheetViewsTimesheetTimeEntrySumHook < Redmine::Hook::ViewListener
+      include TimesheetHookHelper
+      
+      def plugin_timesheet_views_timesheet_time_entry_sum(context={})
+        time_entries = context[:time_entries]
+        costs = time_entries.collect {|time_entry| cost_item(time_entry)}.compact.sum
+        if costs >= 0
+          return td_cell(number_to_currency(costs))
+        else
+          return td_cell('&nbsp;')
+        end
+      end
+    end
+  end
+end

data/lib/redmine_rate/hooks/plugin_timesheet_views_timesheets_time_entry_row_class_hook.rb

@@ -0,0 +1,21 @@
+module RedmineRate
+  module Hooks
+    class PluginTimesheetViewsTimesheetsTimeEntryRowClassHook < Redmine::Hook::ViewListener
+      include TimesheetHookHelper
+
+      def plugin_timesheet_views_timesheets_time_entry_row_class(context={})
+        time_entry = context[:time_entry]
+        return "" unless time_entry
+
+        cost = cost_item(time_entry)
+        return "" unless cost # Permissions
+        
+        if cost && cost <= 0
+          return "missing-rate"
+        else
+          return ""
+        end
+      end
+    end
+  end
+end

data/lib/redmine_rate/hooks/timesheet_hook_helper.rb

@@ -0,0 +1,14 @@
+module TimesheetHookHelper
+  # Returns the cost of a time entry, checking user permissions
+  def cost_item(time_entry)
+    if User.current.logged? && (User.current.allowed_to?(:view_rate, time_entry.project) || User.current.admin?)
+      return time_entry.cost
+    else
+      return nil
+    end
+  end
+
+  def td_cell(html)
+    return content_tag(:td, html, :align => 'right', :class => 'cost')
+  end
+end

data/lib/redmine_rate/hooks/view_layouts_base_html_head_hook.rb

@@ -0,0 +1,9 @@
+module RedmineRate
+  module Hooks
+    class ViewLayoutsBaseHtmlHeadHook < Redmine::Hook::ViewListener
+      def view_layouts_base_html_head(context={})
+        return content_tag(:style, "#admin-menu a.rate-caches { background-image: url('#{image_path('database_refresh.png', :plugin => 'redmine_rate')}'); }", :type => 'text/css')
+      end
+    end
+  end
+end

data/lib/tasks/cache.rake

@@ -0,0 +1,13 @@
+namespace :rate_plugin do
+  namespace :cache do
+    desc "Update Time Entry cost caches for Time Entries without a cost"
+    task :update_cost_cache => :environment do
+      Rate.update_all_time_entries_with_missing_cost
+    end
+
+    desc "Clear and update all Time Entry cost caches"
+    task :refresh_cost_cache => :environment do
+      Rate.update_all_time_entries_to_refresh_cache
+    end
+  end
+end

data/lib/tasks/data.rake

@@ -0,0 +1,163 @@
+namespace :rate_plugin do
+  desc "Export both the Budget and Billing plugin data to a file"
+  task :pre_install_export => ['budget:pre_install_export', 'billing:pre_install_export']
+
+  desc "Check the export against the migrated Rate data"
+  task :post_install_check => ['budget:post_install_check', 'billing:post_install_check']
+
+  namespace :budget do
+    desc "Export the values of the Budget plugin to a file before installing the rate plugin"
+    task :pre_install_export => :environment do
+      
+      unless Redmine::Plugin.registered_plugins[:budget_plugin].version == "0.1.0"
+        puts "ERROR: This task is only needed when upgrading Budget from version 0.1.0 to version 0.2.0"
+        return false
+      end
+      
+      rates = ''
+      # Rate for members
+      Member.find(:all, :conditions => ['rate IS NOT NULL']).each do |member|
+        
+        rates << {
+          :user_id => member.user_id,
+          :project_id => member.project_id,
+          :rate => member.rate
+        }.to_yaml
+
+      end
+
+      File.open(RateConversion::MemberRateDataFile, 'w') do |file|
+        file.puts rates
+      end
+      
+      # HourlyDeliverable.spent and FixedDeliverable.spent
+      deliverables = ''
+      Deliverable.find(:all).each do |deliverable|
+        deliverables << { 
+          :id => deliverable.id,
+          :spent => deliverable.spent
+        }.to_yaml
+      end
+
+      File.open(RateConversion::DeliverableDataFile, 'w') do |file|
+        file.puts deliverables
+      end
+    end
+    
+    desc "Check the values of the export"
+    task :post_install_check => :environment do
+
+      unless Redmine::Plugin.registered_plugins[:budget_plugin].version == "0.2.0"
+        puts "ERROR: Please upgrade the budget_plugin to 0.2.0 now"
+        return false
+      end
+      
+      counter = 0
+      # Member Rates
+      File.open(RateConversion::MemberRateDataFile) do |file|
+        YAML::load_documents(file) { |member_export|
+          user_id = member_export[:user_id]
+          project_id = member_export[:project_id]
+          rate = Rate.find_by_user_id_and_project_id(user_id, project_id)
+
+          if rate.nil?
+            puts "ERROR: No Rate found for User: #{user_id}, Project: #{project_id}"
+            counter += 1
+          else
+            counter += 1 unless RateConversion.compare_values(member_export[:rate], rate.amount, "Rate #{rate.id}'s amount is off")
+          end
+        }
+      end
+
+      # Deliverables
+      File.open(RateConversion::DeliverableDataFile) do |file|
+        YAML::load_documents(file) { |deliverable_export|
+          id = deliverable_export[:id]
+          spent = deliverable_export[:spent]
+          deliverable = Deliverable.find(id)
+          
+          counter += 1 unless RateConversion.compare_values(spent, deliverable.spent, "Deliverable #{id}'s spent is off")
+        }
+      end
+
+      if counter > 0
+        puts "#{counter} errors found." 
+      else
+        puts "No Budget conversation errors found, congrats."
+      end
+    end
+  end
+
+  namespace :billing do
+    desc "Export the values of the Billing plugin to a file before installing the rate plugin"
+    task :pre_install_export => :environment do
+      
+      unless Redmine::Plugin.registered_plugins[:redmine_billing].version == "0.0.1"
+        puts "ERROR: This task is only needed when upgrading Billing from version 0.0.1 to version 0.3.0"
+        return false
+      end
+      
+      invoices = ''
+      
+      FixedVendorInvoice.find(:all).each do |invoice|
+        invoices << { 
+          :id => invoice.id,
+          :number => invoice.number,
+          :amount => invoice.amount,
+          :project_id => invoice.project_id,
+          :type => 'FixedVendorInvoice'
+        }.to_yaml
+      end
+
+      HourlyVendorInvoice.find(:all).each do |invoice|
+        invoices << { 
+          :id => invoice.id,
+          :number => invoice.number,
+          :amount => invoice.amount_for_user,
+          :project_id => invoice.project_id,
+          :type => 'HourlyVendorInvoice'
+        }.to_yaml
+      end
+
+      File.open(RateConversion::VendorInvoiceDataFile, 'w') do |file|
+        file.puts invoices
+      end
+    end
+    
+    desc "Check the values of the export"
+    task :post_install_check => :environment do
+
+      unless Redmine::Plugin.registered_plugins[:redmine_billing].version == "0.3.0"
+        puts "ERROR: Please upgrade the billing_plugin to 0.3.0 now"
+        return false
+      end
+      
+      counter = 0
+
+      File.open(RateConversion::VendorInvoiceDataFile) do |file|
+        YAML::load_documents(file) { |invoice_export|
+          invoice = VendorInvoice.find_by_id(invoice_export[:id])
+
+          if invoice.nil?
+            puts "ERROR: No VendorInvoice found with the ID of #{invoice_export[:id]}"
+            counter += 1
+          else
+            if invoice.type.to_s == "FixedVendorInvoice"
+              counter += 1 unless RateConversion.compare_values(invoice_export[:amount], invoice.amount, "VendorInvoice #{invoice.id}'s amount is off")
+            else
+              counter += 1 unless RateConversion.compare_values(invoice_export[:amount], invoice.amount_for_user, "VendorInvoice #{invoice.id}'s amount is off")
+            end
+            
+          end
+        }
+      end
+
+      if counter > 0
+        puts "#{counter} errors found." 
+      else
+        puts "No Billing conversation errors found, congrats."
+      end
+    end
+  end
+
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/../init"