brisk-bills 0.7.0 → 0.8.1

data/app/controllers/admin/draft_invoices_controller.rb

@@ -0,0 +1,92 @@
+class Admin::DraftInvoicesController < Admin::InvoicesController
+  include Admin::DraftInvoicesHelper
+
+  @invoices_scaffold_config = superclass.instance_variable_get('@invoices_scaffold_config').dup
+
+  invoices_scaffold_config do |config|
+    config.label = "Draft Invoices"
+    
+    config.list.columns.instance_eval do 
+      @set.delete(:is_published)
+      @set.delete(:is_paid?)
+    end
+
+    config.action_links.add :batch_create, :label  => 'Batch Create'
+  end
+  
+  def conditions_for_collection
+    ['is_published = ?', false]
+  end 
+
+  # TODO: Put in a plugin-helper
+  # We need to be sure the view is looking in the right place, this little hack should do it:
+  def self.active_scaffold_paths
+    ret = super
+    ret <<  BRISKBILLS_ROOT+'/app/views/admin/invoices'
+    ret
+  end
+  # /TODO: Put in a plugin-helper
+  
+  def batch_create_on_date_change
+    # This is kind of an annoying way to make a date ...
+    @invoice_date_at = utc_date_from_param(
+      params[:batch_invoice_date_at]
+    ) if params[:batch_invoice_date_at]
+logger.error "Well?" + @invoice_date_at.inspect
+
+    # I didn't really feel the need to create a partial just for this one line:
+    render :inline => '<%= batch_create_clients_form_column(@invoice_date_at) %>' if @invoice_date_at
+  end
+
+  def batch_create
+    if params.has_key? :batch_client
+      invoiceable_client_ids = params[:batch_client].keys.collect(&:to_i)
+
+      if invoiceable_client_ids.length > 0
+        all_activity_types = ActivityType.find(:all)
+
+        invoice_date = utc_date_from_param params[:batch_invoice_date_at]
+        
+        @new_invoices = Client.find(
+          :all, 
+          :conditions => ['id IN (?)', invoiceable_client_ids]
+        ).each do |client|  
+          Invoice.create!(
+            :client => client, 
+            :activity_types => all_activity_types,
+            :issued_on => invoice_date,
+            :activities => Invoice.recommended_activities_for( 
+              client.id, 
+              invoice_date, 
+              all_activity_types 
+            )
+          )
+        end
+
+        do_list
+      end
+
+      render :action => 'batch_create.js'
+    else
+      @invoice_date_at = Time.utc(*Time.now.to_a).prev_month.end_of_month
+      render :action => 'batch_create.html', :layout => false
+    end
+  end
+
+  private 
+  
+  def utc_date_from_param(date_hash)
+    Time.utc(
+      date_hash[:year].to_i, 
+      date_hash[:month].to_i, 
+      date_hash[:day].to_i,
+      date_hash[:hour].to_i,
+      date_hash[:minute].to_i,
+      date_hash[:second].to_i
+    )
+  end
+
+  handle_extensions
+  
+  invoices_scaffold_init
+end

data/app/controllers/admin/{employee_client_labor_rate_controller.rb → employee_client_labor_rates_controller.rb}

@@ -1,4 +1,4 @@
-class Admin::EmployeeClientLaborRateController < ApplicationController
+class Admin::EmployeeClientLaborRatesController < ApplicationController
 
   include AdminLayoutHelper
   include ExtensibleObjectHelper

data/app/controllers/admin/employees_controller.rb

@@ -16,17 +16,16 @@ class Admin::EmployeesController < ApplicationController
     
     config.list.sorting = [{:last_name => :asc}, {:first_name => :asc}]
     
-    config.nested.add_link "Labor Rates", [:employee_client_labor_rates]
+    config.nested.add_link "Labor Rates", :employee_client_labor_rates
     
     config.create.columns = [:first_name, :last_name, :email_address, :password, :phone_extension, :login_enabled]
-    config.update.columns = [:first_name, :last_name, :email_address, :password, :phone_extension, :is_active, :login_enabled]
-    
+    config.update.columns = [:first_name, :last_name, :email_address, :password, :phone_extension, :is_active, :login_enabled]    
     config.full_list_refresh_on = [:update, :destroy]
   end
   
   def conditions_for_collection
     ['is_active = ?', true]
   end
- 
+  
   handle_extensions
 end

data/app/controllers/admin/invoices_controller.rb

@@ -5,8 +5,23 @@ class Admin::InvoicesController < ApplicationController
   include ::InvoicePdfHelper
   
   add_layout_conditions :except => 'download'
+  
+  # TODO: Put in a plugin-helper
+  def self.invoices_scaffold_config(&block)
+    @invoices_scaffold_config ||= []
+    @invoices_scaffold_config << block.to_proc  
+  end
+  
+  def self.invoices_scaffold_init
+    # I dont love this mechanism of scaffold_init - but I think its going to work quite well...
+    configs = @invoices_scaffold_config
+
+    active_scaffold(:invoice){|c| configs.each{|ac| ac.call c if ac.respond_to? :call} }
+  end
+  # /TODO: Put in a plugin-helper
+  
 
-  active_scaffold :invoices_with_total do |config|
+  invoices_scaffold_config do |config|
     config.label = "Invoices"
 
     config.show.columns = config.columns = [
@@ -25,10 +40,12 @@ class Admin::InvoicesController < ApplicationController
       :created_at, 
       :updated_at
     ]
+    
+    config.columns[:is_paid?].sort_by :sql => '`invoices`.is_paid'
 
-    config.columns[:is_paid?].sort_by :sql => '`invoices_with_totals`.is_paid'
-
+    config.columns[:id].includes = [:payment_assignments]
     config.columns[:id].label = 'Num'
+    
     config.columns[:is_published].label = 'Pub?'
     config.columns[:is_paid?].label = 'Paid?'
     config.columns[:activity_types].label = 'Include Activities'
@@ -45,27 +62,41 @@ class Admin::InvoicesController < ApplicationController
     config.list.columns =[:id, :issued_on, :client,  :amount, :is_published, :is_paid?]
     config.list.sorting = [{:issued_on => :desc}]
     
-    config.create.columns = config.update.columns = [:issued_on, :is_published, :client, :activity_types, :comments]
+    config.create.columns = config.update.columns = [
+      :issued_on, :client, :activity_types, :comments
+    ]
+
+    config.create.link
 
-    config.action_links.add ActiveScaffold::DataStructures::ActionLink.new(
+    config.action_links.add(
+      'toggle_published', 
+      :label  => 'Publish', 
+      :type   => :member,
+      :inline => true,
+      :page   => false,
+      :position => false 
+    )
+
+    config.action_links.add(
       'download', 
       :label  => 'Download', 
-      :type   => :record,
+      :type   => :member,
       :inline => false,
       :page   => true
     )
 
-    config.nested.add_link "Activities", [:activities]
-    
+    config.nested.add_link "Activities", :activities     
     config.full_list_refresh_on = [:update, :create]
 
   end
   
+  # override_form_field_partial in the helper gets buggered out b/c our controller name doesn't match
+  # the model name. This fixes that:
   def self.active_scaffold_controller_for(klass)
-    (klass == Activity) ? Admin::ActivitiesWithPricesController : super
+    (klass == Activity) ? Admin::ActivitiesWithPricesController : self
   end
 
-  # We ovverride the defaut behavior here only so that we can use this method as a hook to detyermine the invoice.activity_type_ids
+  # We overide the defaut behavior here only so that we can use this method as a hook to detyermine the invoice.activity_type_ids
   # Before they've been updated by the form. We reference @activity_type_ids_before in before_update_save to determine whether we
   # need to update the activity associations for this invoice.
   def update_record_from_params(*args)
@@ -75,7 +106,8 @@ class Admin::InvoicesController < ApplicationController
 
   def before_update_save(invoice)
     super
-       
+    
+    # Here we handle activity assignments:
     invoice.activities = invoice.recommended_activities if (
       invoice.new_record? or (
         !invoice.is_published and
@@ -84,61 +116,85 @@ class Admin::InvoicesController < ApplicationController
         (invoice.issued_on_changed? || (@activity_type_ids_before != invoice.activity_type_ids))
       )
     )
-
-    invoice.payment_assignments.clear if !invoice.is_published and invoice.is_published_changed?
-
-    # We're going to need this in the after_update_save... Note it now.
-    @invoice_changes = invoice.changes.keys.collect(&:to_sym)
-    @invoice_new_record = invoice.new_record?
   end
 
   alias before_create_save before_update_save
 
-  def after_update_save(invoice)
-    super
-
-    if successful? and invoice.is_published and (@invoice_new_record || @invoice_changes.include?(:is_published))
-      # Unfortunately we have to assign payments using the quick_create and not by concat'ing on the
-      # invoice AssociationProxy. THis is due to a bug in my InvoicesWithTotal wrapper that I think is related
-      # to the association proxy not resettting its owenr id on an id change (as is the case of a create)
-      invoice.client.recommend_payment_assignments_for(invoice.amount).each do |ip|
-         InvoicePayment.quick_create! invoice.id, ip.payment_id, ip.amount
-      end
-
-      define_invoice invoice
-      
-      attachments = [
-        {
-        :content_type => "application/pdf", 
-        :body         => render_to_string(:action => 'download', :layout => false),
-        :disposition  => "attachment",
-        :filename     => @rails_pdf_name
-        }
-      ]
-      
-      mail = Notifier.deliver_invoice_available @invoice, @client, @footer_text, attachments
-      
-      dest_addresses = []
-      dest_addresses += mail.to_addrs if mail.to_addrs
-      dest_addresses += mail.cc_addrs if mail.cc_addrs
-      
-      dest_addresses.collect!{|t_a| '%s <%s>' % [t_a.name, t_a.address] }
-      
-      flash[:warning]  = "Invoice e-mailed to : %s" % dest_addresses.join(',')
-    end
-  end
-    
-  alias after_create_save after_update_save
-
   def download
     define_invoice Invoice.find(params[:id].to_i, :include => [:client])
     
     rescue 
       render :file => RAILS_ROOT+'/public/500.html', :status => 500
   end
+  
+  def toggle_published
+    if params[:is_confirmed] == '1'
+      invoice = find_if_allowed(params[:id], :toggle_published)
+      
+      invoice.is_published = !invoice.is_published
+      invoice.payment_assignments.clear unless invoice.is_published
+      invoice.save!
+
+      if invoice.is_published
+        # Unfortunately we have to assign payments using the quick_create and not by concat'ing on the
+        # invoice AssociationProxy. This is due to a bug in my InvoicesWithTotal wrapper that I think is related
+        # to the association proxy not resettting its owenr id on an id change (as is the case of a create)
+        invoice.client.recommend_payment_assignments_for(invoice.amount).each do |ip|
+           InvoicePayment.quick_create! invoice.id, ip.payment_id, ip.amount
+        end
+    
+        # Send the notifier
+        if params[:email_invoice].to_i == 1
+          define_invoice invoice
+          
+          attachments = [
+            {
+            :content_type => "application/pdf", 
+            :body         => render_to_string(:action => 'download', :layout => false),
+            :disposition  => "attachment",
+            :filename     => @rails_pdf_name
+            }
+          ]
+          
+          mail = Notifier.deliver_invoice_available invoice, @client, @footer_text, attachments
+          
+          dest_addresses = []
+          dest_addresses += mail.to_addrs if mail.to_addrs
+          dest_addresses += mail.cc_addrs if mail.cc_addrs
+          
+          dest_addresses.collect!{|t_a| '%s <%s>' % [t_a.name, t_a.address] }
+          
+          flash[:warning]  = "Invoice e-mailed to : %s" % dest_addresses.join(',')
+        end
+      end
+
+      render(:update) do |page| 
+        # Close the "Nested" Div, if it's open:
+        page << 'if($(%s)){Element.remove(%s);};' % ([element_row_id(:action => :nested, :id => invoice.id).to_json]*2)
+
+        page.replace(
+          element_row_id(:action => :list, :id => invoice.id), 
+          :partial => 'list_record', 
+          :locals => {:record => invoice}
+        )
+        
+        # Update the flash as well, if needed:
+        page.replace_html active_scaffold_messages_id, :partial => 'messages'
+      end
+    else
+      @record = Invoice.find params[:id].to_i, :include => [:payment_assignments]
+
+      render :action => :confirm_publish_modal, :layout => false
+    end
+  end
 
   private
+ 
   
+  def custom_finder_options
+    {:from => 'invoices_with_totals AS invoices'}
+  end
+
   BAD_INDIFFERENTIZE_VARS =  /^\@(#{%w(
     request_origin _request active_scaffold_observations variables_added before_filter_chain_aborted
     rendering_runtime query action_name _flash performed_render url _headers _cookies db_rt_after_render
@@ -198,4 +254,6 @@ class Admin::InvoicesController < ApplicationController
   end
 
   handle_extensions
+  
+  invoices_scaffold_init
 end

data/app/controllers/admin/payments_controller.rb

@@ -3,79 +3,206 @@ class Admin::PaymentsController < ApplicationController
   include ExtensibleObjectHelper
   include ApplicationHelper # We need h_money below...
 
+  VALID_INVOICE_ASSIGNMENT_INPUT = /^invoice_assignments_([\d]+)_amount$/
+  VALID_MONEY_INPUT = /^(?:[ ]*([\d]+\.[\d]{0,2}|[\d]+)[ ]*|)$/
+
+  class ObservedInvalidAmount < StandardError; end
+
   active_scaffold :payment do |config|
     config.label = "Payments"
 
-    config.columns = [:paid_on, :client, :payment_method, :payment_method_identifier, :amount, :invoice_assignments, :amount_unallocated, :created_at, :updated_at]
+    config.columns = [
+      :id,
+      :paid_on, 
+      :client, 
+      :payment_method, 
+      :payment_method_identifier, 
+      :amount, 
+      # Unfortunately, if I actually tried to make the name of this column "invoice_assignments"
+      # active_scaffold would try to interpret the post on its own and get in my way:
+      :assignments,
+      :amount_unallocated, 
+      :created_at, 
+      :updated_at,
+      :is_allocated?
+    ]
+    
+    config.show.columns = [
+      :id,
+      :paid_on, 
+      :client, 
+      :payment_method, 
+      :payment_method_identifier, 
+      :amount, 
+      :invoice_assignments,
+      :amount_unallocated, 
+      :is_allocated?,
+      :created_at, 
+      :updated_at
+    ]
+
+    config.columns[:id].label = 'Num'
 
     config.columns[:client].form_ui = :select
     config.columns[:client].sort_by :sql => 'clients.company_name'
     
+    config.columns[:is_allocated?].label = "Alloc?"
+    config.columns[:is_allocated?].includes = [:invoice_assignments]
+    
+    config.columns[:payment_method_identifier].label = "Identifier"
+    
+    config.columns[:payment_method].label = 'Method'
     config.columns[:payment_method].form_ui = :select
     config.columns[:payment_method].sort_by :sql => 'payment_methods.name'
     
-    config.columns[:payment_method_identifier].description = 'Last four card digits, check number...'
-    config.columns[:payment_method_identifier].label = 'Method Identifier'
-
     config.columns[:amount_unallocated].label = 'Unallocated'
-    config.columns[:invoice_assignments].label = 'Posted To'
+    config.columns[:assignments].label = 'Applies To'
     
     config.columns[:amount].sort_by :sql => 'amount_in_cents'
     
-    config.list.columns =[:client, :payment_method, :amount, :paid_on]
+    config.list.columns =[:id, :client, :payment_method,:payment_method_identifier, :amount,:is_allocated?, :paid_on]
     config.list.sorting = [{:paid_on => :desc}]
 
     config.create.columns = config.update.columns = [
       :paid_on, 
       :client, 
+      :amount,
       :payment_method, 
-      :payment_method_identifier, 
-      :amount
-#      :amount_unallocated, 
-#      :invoice_assignments
+      :payment_method_identifier,
+      :amount_unallocated, 
+      :assignments
     ]
-    
-    config.update.link = nil
-    
-#    observe_active_scaffold_form_fields :fields => %w(client amount), :action => :on_invoice_assignment_observation
+
+    observe_active_scaffold_form_fields :fields => %w(client amount), :action => :on_assignment_observation
   end
 
-  def before_update_save(payment)      
-    payment.invoice_assignments = payment.client.recommend_invoice_assignments_for payment.amount
+  # In here we update all the invoice assignments
+  def before_update_save(payment)
+    # Let's create a lookup map from the input params to make this easier:
+    input_assignments = {}
+    params[:record][:invoice_assignments].try(:each_pair) do |inv_id, fields|
+      input_assignments[inv_id.to_i] = Money.new(fields[:amount].tr('^\-0-9','').to_i)
+    end
+
+    assignment_deletes = []
+    # First we iterate through the existing relationships:
+    payment.invoice_assignments.each do |asgn|
+      # Did the assignment get changed by the input? If so...
+      if (
+        input_assignments.has_key?(asgn.invoice_id) && 
+        input_assignments[asgn.invoice_id] != asgn.amount
+      )
+        # They set this asignment to zero - which means we remove the assignment:
+        if input_assignments[asgn.invoice_id] == Money.new(0)
+          # Mark this assignment for deletion below
+          assignment_deletes << asgn
+        else # assign the new value:
+          asgn.amount = input_assignments[asgn.invoice_id]
+        end
+      end
+    end
+  
+    # THis is a little more efficient than deleting in the loop above. Also,
+    # I think there's a bug whereby the iterator stops running as soon as you delete somethign in the 
+    # assignment collection. This causes subsequent assignments not to run..
+    payment.invoice_assignments.delete *assignment_deletes
+    
+    # And then we go through the open invoices to find if new assignments need to be created:
+    payment.client.unpaid_invoices.each do |inv|
+      # We need to add a new assignment if there's a non-zero value
+      payment.invoice_assignments.build(
+          :invoice_id => inv.id, 
+          :amount => input_assignments[inv.id]
+        ) if (
+        # We want to make sure we're not creating an assignment that already exists
+        !payment.invoice_assignments.any?{|asgn| asgn.invoice_id == inv.id} &&
+        input_assignments.has_key?(inv.id) &&
+        input_assignments[inv.id] != Money.new(0)
+      )
+    end
   end
 
   alias before_create_save before_update_save
 
+  def on_assignment_observation
+    @observed_column = params[:observed_column]
 
-  def on_invoice_assignment_observation
-    record_id = (/^[\d]+$/.match(params[:record_id])) ? params[:record_id].to_i : nil
-    
-    # TODO: if amount is no integer - highlight...
-    
-    render(:update) do |page|
-      
-      #TODO: We need to load the pre-existing payment here...
+    # First let's load the record in question (or create one) ...
+    @record = (/^[\d]+$/.match(params[:record_id])) ? 
+      Payment.find(params[:record_id].to_i) : Payment.new
+
+    # We'll need these later in the helper/rjs...
+    params[:id] = params[:record_id] # This is a hack to make the options_for_column work as expected
+    define_scaffold_observations
+
+    # We don't have to raise on this one really. Its not consequential if this is screwy
+    @record.client_id = params[:client].to_i if /^[\d]+$/.match params[:client]
+
+    # Let's make sure all the amounts we've been given are acceptable:
+    @invalid_amount_columns = params.to_enum(:each_pair).collect{|key,value| 
+      key if (VALID_INVOICE_ASSIGNMENT_INPUT.match key or key == 'amount') and !VALID_MONEY_INPUT.match value
+    }.compact
+
+    if @invalid_amount_columns.length > 0
+      # We'll end up needing this when we're clearing out amounts outstanding due to a mis-type
+      @invoice_map = Invoice.find(
+        :all,
+        :conditions => ['id IN (?)', @invalid_amount_columns.collect{|colname| $1 if VALID_INVOICE_ASSIGNMENT_INPUT.match colname}]
+      ).inject({}){|ret, inv| ret.merge({inv.id => inv})}
       
-      # Let's do some (minimal) Amount input handling
-      unless params[:amount].empty?
-        begin
-          record_amount_js_id = "record_amount_#{record_id}"
-          
-          new_amount = Money.new($1.to_f*100) if /^[ ]*([\d]+\.[\d]{0,2}|[\d]+)[ ]*$/.match params[:amount]
-          
-          raise StandardError unless new_amount
-          
-          page[record_amount_js_id].value = new_amount.to_s
-          page.replace_html "record_unallocated_amount_#{record_id}", :text => h_money(new_amount)
-        rescue
-          page[record_amount_js_id].value = ''
-          page[record_amount_js_id].focus
-          page.visual_effect :highlight, record_amount_js_id, :duration => 3, :startcolor => "#FF0000"
-        end
+      raise ObservedInvalidAmount
+    end
+
+    # This is an important field to get right. Remember that we already validating this param above:
+    @record.amount = Money.new(params[:amount].to_f*100) if params.has_key? :amount
+
+    case @observed_column
+      when /^(?:amount|client)$/
+        # Let's try to guess the right assignments automatically:
+        @record.invoice_assignments = @record.client.recommend_invoice_assignments_for(
+          @record.amount
+        ) if @record.client and @record.amount
+
+      when VALID_INVOICE_ASSIGNMENT_INPUT
+        @observed_invoice = Invoice.find $1.to_i
+
+        update_assignments_from_params @record
+
+        @observed_assignment = @record.invoice_assignments.to_a.find{|ia| ia.invoice_id == @observed_invoice.id}
+    end
+
+    rescue ObservedInvalidAmount
+      render :action => :observation_error
+  end
+
+  private
+
+  def update_assignments_from_params(record)
+    # First we build a lookup with all ids that were passed in the params, 
+    # and which have an assignment amount greater than 0
+    assignments = {}
+    
+    params.each_pair do |key,value|
+      if VALID_INVOICE_ASSIGNMENT_INPUT.match key
+        inv_id = $1.to_i
+        assignments[inv_id] = Money.new(params[key].to_f*100) 
       end
+    end
+
+    # Now go ahead and delete the invoice_assignments that no longer have money attributed to them
+    record.invoice_assignments.each do |ia|
+      record.invoice_assignments.delete ia unless assignments.keys.include? ia.invoice_id
+    end
+  
+    # And lastly, add new the assignments and/or update existing assignments in the record:
+    assignments.each_pair do |inv_id,amount|
+      ia = record.invoice_assignments.to_a.find{|ia| ia.invoice_id == inv_id}
+      ia ||= record.invoice_assignments.build :invoice_id => inv_id
       
-      # TODO: Generate the invoices div...
+      ia.amount = amount
     end
+    
+    record
   end
 
   handle_extensions