brisk-bills 0.6.0 → 0.7.0

data/app/models/client_representative.rb

@@ -18,5 +18,13 @@ class ClientRepresentative < ActiveRecord::Base
     
     ret
   end
-  
+
+  # This fixes (I guess its a bug?) in _add_existing_form.html when ClientReps are being shown
+  # as a sublist in Clients, and the user chooses to "Add Existing". Without this - the order
+  # Is totally effed.  
+  def self.find(*args)
+    (args == [:all]) ? super(:all, :order => 'first_name ASC, last_name ASC') : super(*args)
+  end
+
+
 end

data/app/models/employee.rb

@@ -44,6 +44,26 @@ class Employee < ActiveRecord::Base
         true
     end
   end
-  
+
+  # There were some issues in rails 2.3.2 that caused associations (slimtimer/credential/etc) to not save without this hack
+  # we may have to do it for all active record objects in the project ...
+  def with_unsaved_associated
+    associations_for_update.all? do |association|
+      association_proxy = instance_variable_get("@#{association.name}")
+
+      if association_proxy
+        records = association_proxy
+
+        records = [records] unless records.is_a? Array # convert singular associations into collections for ease of use
+
+        records.select {|r| r.changed? and not r.readonly?}.all?{|r| yield r} # must use select instead of find_all, which Rails overrides on association proxies for db access
+      else
+        true
+      end
+
+      association_proxy
+    end
+  end
+
   handle_extensions
 end

data/app/models/employee/slimtimer.rb

@@ -5,11 +5,22 @@ class Employee::Slimtimer < ActiveRecord::Base
    has_many :time_entries, :class_name => 'SlimtimerTimeEntry', :dependent => :destroy, :foreign_key => :employee_slimtimer_id
 
    validates_presence_of [:employee_id, :api_key, :username, :password]
+
 end
 
 Employee.class_eval do
    has_one :slimtimer, :class_name => 'Employee::Slimtimer', :dependent => :destroy, :foreign_key => :employee_id
+   
+   # This ensures validation and save in the employee ActiveScaffold do_cupdate & do_create 
+   def scaffold_update_follow_with_slimtimer
+     (scaffold_update_follow_without_slimtimer || []) << :slimtimer
+   end
 
+   # We kind of need for there to be a scaffold_update_follow if alias_method_chain is to work:
+   def scaffold_update_follow; end unless self.respond_to? :scaffold_update_follow
+   
+   alias_method_chain :scaffold_update_follow, :slimtimer
+  
    def slimtimer_api_key
      slimtimer.api_key unless slimtimer.nil?
    end

data/app/models/invoice.rb

@@ -3,20 +3,16 @@ class Invoice < ActiveRecord::Base
   
   # NOTE: this has to be above the has_many, otherwise activities would get nullified before this callback had a chance to return fals
   before_destroy :ensure_not_published_on_destroy
-  before_destroy :ensure_were_the_most_recent
 
   before_update :ensure_not_published_on_update
-
-  after_create :reattach_activities
-  after_update :reattach_activities
-
-  after_update  :mark_invoice_payments
-  after_create  :mark_invoice_payments
-  after_destroy :remove_invoice_payments
+  
+  # NOTE: If we ever try removing this - we have a problem with invoice_payments exceeding the invoice price when activities are added/removed
+  before_save :clear_invoice_payments_if_unpublished
 
   belongs_to :client
   has_many :activities, :dependent => :nullify
-  has_many :payments, :through => 'invoice_payments'
+  has_many :payments, :through => :assigned_payments
+  has_many :payment_assignments, :class_name => 'InvoicePayment', :dependent => :delete_all
   
   has_and_belongs_to_many(
     :activity_types, 
@@ -27,6 +23,8 @@ class Invoice < ActiveRecord::Base
   )
   
   validates_presence_of :client_id, :issued_on
+  validate :validate_invoice_payments_not_greater_than_amount
+  validate :validate_payment_assignments_only_if_published
 
   # This just ends up being useful in a couple places
   ACTIVITY_TOTAL_SQL = '(IF(activities.cost_in_cents IS NULL, 0, activities.cost_in_cents)+IF(activities.tax_in_cents IS NULL, 0, activities.tax_in_cents))'
@@ -36,53 +34,13 @@ class Invoice < ActiveRecord::Base
     end_of_last_month = Time.utc(*Time.now.to_a).last_month.end_of_month
     self.issued_on = end_of_last_month unless self.issued_on
   end
-    
-  def invalid_if_published(collection_record = nil)
-    raise "Can't adjust an already-published invoice." if !new_record? and is_published
+  
+  def validate_payment_assignments_only_if_published
+    errors.add :payment_assignments, "can only be set for published invoices" if !is_published and payment_assignments and payment_assignments.length > 0 
   end
   
-  def reattach_activities
-    included_activity_types = activity_types.collect{ |a| a.label.downcase }
-    unincluded_activity_types = ActivityType.find(:all).collect{ |a| a.label.downcase } - included_activity_types
-
-    # First we NULL'ify (remove) existing attachments that no longer should be:
-    nullify_conditions = []
-    nullify_parameters = [] 
-        
-    # Conditions for occurance adjutments
-    nullify_conditions << '(DATEDIFF(occurred_on, DATE(?)) > 0)'
-    nullify_parameters << issued_on
-    
-    # For the ActivityType Adjustments:
-    unless unincluded_activity_types.empty?
-      nullify_conditions << '(%s)' % ( ['activity_type = ?'] * unincluded_activity_types.size).join(' OR ')
-      nullify_parameters += unincluded_activity_types
-    end
-
-    Activity.update_all( 
-      'invoice_id = NULL', 
-      [ ['invoice_id = ?', 'is_published = ?', ('(%s)' % nullify_conditions.join(' OR ')) ].join(' AND ') ]+
-      [id, true]+nullify_parameters
-    ) unless new_record?
-    
-    # Now we attach the new records :
-    update_where = [
-      ['invoice_id IS NULL'],
-      ['is_published = ?', true],
-      ['client_id = ?', client_id],
-      ['DATEDIFF(occurred_on, DATE(?)) <= 0', issued_on],
-      
-      # Slightly more complicated, for the type includes:
-      ( (included_activity_types.size > 0) ? 
-        [ '('+(['activity_type = ?'] * included_activity_types.size).join(' OR ')+')', included_activity_types ] :
-        [ 'activity_type IS NULL' ] )
-    ]
-    
-    Activity.update_all(
-      ['invoice_id = ?', id ],
-      # This is what ActiveRecord actually expects...
-      update_where.collect{|c| c[0]}.join(' AND ').to_a + update_where.reject{|c| c.length < 2 }.collect{|c| c[1]}.flatten
-    )
+  def invalid_if_published(collection_record = nil)
+    raise "Can't adjust an already-published invoice." if !new_record? and is_published
   end
   
   def is_most_recent_invoice?
@@ -91,13 +49,6 @@ class Invoice < ActiveRecord::Base
     (newest_invoice.nil? or newest_invoice.id == id) ? true : false
   end
   
-  def ensure_were_the_most_recent
-    unless is_most_recent_invoice?
-      errors.add_to_base "Can't destroy an invoice if its not the client's most recent invoice"
-      return false
-    end
-  end
-  
   def ensure_not_published_on_destroy
     if is_published and !changes.has_key? :is_published
       errors.add_to_base "Can't destroy a published invoice"
@@ -114,30 +65,46 @@ class Invoice < ActiveRecord::Base
 
     errors.add_to_base(
       "Invoice can't be updated once published."
-    ) if is_published and changes.reject{|k,v| k == 'is_published'}.length > 0
+    ) if is_published and changes.reject{|k,v| /(?:is_published|payment_assignments)/.match k}.length > 0
 
-    errors.add_to_base(
-      "Invoice can't be unpublished, unless its the newest invoice in the client's queue."
-    ) if changes.has_key?('is_published') and is_published_was and !is_most_recent_invoice?
   end
 
-  def taxes_total
-    process_total :taxes_total, :tax_in_cents
+  def validate_invoice_payments_not_greater_than_amount
+    inv_amount = self.amount
+    assignment_amount = self.payment_assignments.inject(Money.new(0)){|sum,ip| ip.amount+sum }
+    
+    # We use the funky :> /:< to differentiate between the case of a credit invoice and a (normal?) invoice
+    errors.add :payment_assignments, "exceeds invoice amount" if inv_amount >= 0 and self.amount < assignment_amount
+  end
+
+  def authorized_for?(options)
+    case options[:action].to_s
+      when /^(destroy)$/
+        !is_published
+      else
+        true
+    end
+  end
+  
+  def taxes_total( force_reload = false )
+    (attribute_present? :tax_in_cents and !force_reload) ?
+      Money.new(read_attribute(:tax_in_cents).to_i) :
+      self.activities.inject(Money.new(0)){|sum,a| sum + ((a.tax) ? a.tax : Money.new(0)) }
   end
 
-  def sub_total
-    process_total :sub_total, :cost_in_cents
+  def sub_total( force_reload = false )
+    (attribute_present? :cost_in_cents and !force_reload) ?
+      Money.new(read_attribute(:cost_in_cents).to_i) :
+      self.activities.inject(Money.new(0)){|sum,a| sum + ((a.cost) ? a.cost : Money.new(0)) }
   end
   
   def amount( force_reload = false )
-    (attribute_present? :amount_in_cents  and !force_reload) ?
+    (attribute_present? :amount_in_cents and !force_reload) ?
       Money.new(read_attribute(:amount_in_cents).to_i) :
-      process_total( :amount, ACTIVITY_TOTAL_SQL )
+      self.activities.inject(Money.new(0)){|sum,a| sum + ((a.cost) ? a.cost : Money.new(0)) + ((a.tax) ? a.tax : Money.new(0)) }
   end
   
-  def grand_total
-    process_total :grand_total, ACTIVITY_TOTAL_SQL
-  end
+  alias :grand_total :amount
   
   def name  
     '"%s" Invoice on %s'  % [ (client) ? client.company_name : '(Unknown Client)', issued_on.strftime("%m/%d/%Y %I:%M %p") ]
@@ -151,46 +118,6 @@ class Invoice < ActiveRecord::Base
       ('$%.2f' % amount.to_s).gsub(/(\d)(?=\d{3}+(\.\d*)?$)/, '\1,')
     ]
   end
-
-  def remove_invoice_payments
-    InvoicePayment.destroy_all ['invoice_id = ?', id]    
-  end
-  
-  def mark_invoice_payments   
-    if changes.has_key? "is_published"
-      remove_invoice_payments
-      
-      if is_published
-        unallocated_payments = Payment.find_with_totals( 
-          :all, 
-          :conditions => [
-            'client_id = ? AND (payments.amount_in_cents - IF(payments_total.amount_allocated_in_cents IS NULL, 0, payments_total.amount_allocated_in_cents) ) > ?', 
-            client_id, 
-            0
-          ] 
-        )
-    
-        current_client_balance = 0.0.to_money
-        unallocated_payments.each { |pmnt| current_client_balance -= pmnt.amount_unallocated }
-        
-        invoice_balance = amount
-    
-        unallocated_payments.each do |unallocated_pmnt|
-          break if invoice_balance == 0 or current_client_balance >= 0
-          
-          payment_allocation = (unallocated_pmnt.amount_unallocated > invoice_balance) ?
-            invoice_balance :
-            unallocated_pmnt.amount_unallocated
-          
-          InvoicePayment.create! :invoice => self, :payment => unallocated_pmnt, :amount => payment_allocation
-          
-          invoice_balance -= payment_allocation
-          current_client_balance += payment_allocation
-        end        
-      end
-    end
-    
-  end
   
   def paid_on
     raise StandardError unless is_paid?
@@ -209,7 +136,7 @@ class Invoice < ActiveRecord::Base
   def is_paid?( force_reload = false )
     (attribute_present? :is_paid  and !force_reload) ? 
       (read_attribute(:is_paid).to_i == 1) :
-      amount_outstanding.zero?
+      amount_outstanding(true) <= 0
   end
   
   def amount_paid( force_reload = false )
@@ -220,8 +147,49 @@ class Invoice < ActiveRecord::Base
     )
   end
   
-  def amount_outstanding
-    amount - amount_paid
+  def amount_outstanding( force_reload = false )
+    (attribute_present? :amount_outstanding_in_cents and !force_reload) ? 
+      Money.new(read_attribute(:amount_outstanding_in_cents).to_i) :
+      (amount(true) - amount_paid(true))
+  end
+
+  # This is a shortcut to the self.recommended_activities_for , and is provided as a shortcut when its necessary to update an existing invoice's
+  # activities inclusion
+  def recommended_activities
+    Invoice.recommended_activities_for client_id, issued_on, self.activity_types, self.id
+  end
+
+  # Given a client_id, cut_at_or_before date, and (optionally) an array of types, we'll return the activities that should go into a corresponding invoice.
+  # THis was placed here, b/c its conceivable that in the future, we may support an array for the client_id parameter...
+  def self.recommended_activities_for(for_client_id, occurred_on_or_before, included_activity_types, for_invoice_id = nil)
+    for_client_id = for_client_id.id if for_client_id.class == Client
+    for_invoice_id = for_invoice_id.id if for_invoice_id.class == Invoice
+    
+    included_activity_types = included_activity_types.collect{|a| a.label.downcase}
+    
+    conditions = [
+      'is_published = ? AND client_id = ? AND DATEDIFF(occurred_on, DATE(?)) <= 0',
+      true,
+      for_client_id,
+      occurred_on_or_before
+    ]
+    
+    # Slightly more complicated, for the type includes:
+    if included_activity_types and included_activity_types.size > 0
+      conditions[0] += ' AND ('+(['activity_type = ?'] * included_activity_types.size).join(' OR ')+')'
+      conditions.push *included_activity_types
+    else
+      conditions[0] += ' AND activity_type IS NULL'
+    end
+    
+    if for_invoice_id
+      conditions[0] += ' AND ( invoice_id IS NULL OR invoice_id = ? )'
+      conditions << for_invoice_id
+    else
+      conditions[0] += ' AND invoice_id IS NULL'
+    end
+
+    Activity.find :all, :conditions => conditions
   end
 
   def self.find_with_totals( how_many = :all, options = {} )
@@ -251,6 +219,9 @@ class Invoice < ActiveRecord::Base
           'invoices.client_id',
           'invoices.comments',
           'invoices.issued_on',
+          'invoices.is_published',
+          'invoices.created_at',
+          'invoices.updated_at',
           "#{cast_amount} AS amount_in_cents",
           "#{cast_amount_paid} AS amount_paid_in_cents",
           "#{cast_amount} - #{cast_amount_paid} AS amount_outstanding_in_cents"
@@ -261,19 +232,12 @@ class Invoice < ActiveRecord::Base
     )
   end
 
-  def authorized_for?(options)
-    case options[:action].to_s
-      when /^(update|destroy)$/
-        (is_published and !is_most_recent_invoice?) ? false : true
-      else
-        true
-    end
-  end
-
   private 
-  
-  def process_total(name, field_sql)   
-    Money.new Activity.sum(field_sql, :conditions => ['invoice_id = ?', id]).to_i
+
+  # When/if we save an invoice, and we determine that its changed or created as unpublished, we need to ensure that no payments are assigned to the invoice.
+  # This means deleting any existing assignments should there be any.
+  def clear_invoice_payments_if_unpublished
+    payment_assignments.clear if changes.has_key? "is_published" and !is_published
   end
 
   handle_extensions

data/app/models/invoice_payment.rb

@@ -5,4 +5,58 @@ class InvoicePayment < ActiveRecord::Base
   belongs_to :invoice
   
   money :amount, :currency => false
+  
+  validates_numericality_of :amount, :greater_than_or_equal_to => 0
+  validate :amount_not_greater_than_payment_or_invoice_totals
+  validate :validate_invoice_is_published
+
+  # Ensure the assigned invoice is_published, otherwise, we shouldn't be able to mark it paid
+  def validate_invoice_is_published
+    errors.add :invoice, "can't be assigned to an unpublished invoice" if invoice and !invoice.is_published
+  end
+  
+  def label
+    '%s @ (Invoice %d, Payment %d)' % [amount.format, invoice.id,payment.id,  ]
+  end
+
+  # This is just to make the code a little easier to type/read. Its a create!, just without all the option verbosity.
+  # Note: We accept either and invoice object or invoice_id, and either a payment object or payment_id
+  def self.quick_create!(invoice_id, payment_id, amount)    
+    InvoicePayment.create!(
+      :invoice_id => (invoice_id.class == Invoice) ? invoice_id.id : invoice_id, 
+      :payment_id => (payment_id.class == Payment) ? payment_id.id : payment_id, 
+      :amount     => amount.to_money
+    )
+  end
+
+  # Here, we verify that newly created and/or updated InvoicePayments, won't have an amount which adds up to a greater value 
+  # than would be possible for the associated invoice or payment
+  def amount_not_greater_than_payment_or_invoice_totals
+    conditions_fields = []
+    conditions_values = []    
+
+    # If we're updating an existing payment, it gets a little more complicated:
+    if id
+      conditions_fields << 'id != ?'
+      conditions_values << id
+    end
+    
+    errors.add :amount, "exceeds the payment's remainder amount" if payment_id and payment.amount < (
+      Money.new(
+        InvoicePayment.sum(
+          :amount_in_cents, 
+          :conditions => [(conditions_fields+['payment_id = ?']).join(' AND ')]+conditions_values+[payment_id] 
+        ).to_i
+      ) + amount)
+
+    # This could act flaky on you if you didn't specify activities for your invoice at creation time (and did specify invoice_payments)
+    # this , b/c we're checking the invoice amount below and unlike payments, invoices have no amount field
+     errors.add :amount, "exceeds the invoice's remainder balance" if invoice_id and invoice.amount < (
+      Money.new(
+        InvoicePayment.sum(
+          :amount_in_cents, 
+          :conditions => [(conditions_fields+['invoice_id = ?']).join(' AND ')]+conditions_values+[invoice_id] 
+        ).to_i
+      ) + amount)
+  end
 end

data/app/models/payment.rb

@@ -2,18 +2,17 @@ class Payment < ActiveRecord::Base
   include ExtensibleObjectHelper
   include MoneyModelHelper
   
-  after_create  :create_invoice_payments
-  after_destroy :destroy_invoice_payments
-  # NOTE: after_update is not needed , because payment's can't be updated...
-  
   belongs_to :client
   belongs_to :payment_method
   
-  has_many :invoices, :through => 'invoice_payments'
+  has_many :invoices, :through => :assigned_payments
+  has_many :invoice_assignments, :class_name => 'InvoicePayment', :dependent => :delete_all
   
   validates_presence_of :client_id, :payment_method_id
   validates_numericality_of :amount, :allow_nil => false
-  
+  validates_numericality_of :amount, :greater_than_or_equal_to => 0
+  validate :validate_invoice_payments_not_greater_than_amount
+    
   money :amount, :currency => false
   
   def initialize(*args)
@@ -21,58 +20,36 @@ class Payment < ActiveRecord::Base
     self.paid_on = Time.now.beginning_of_day if paid_on.nil?
   end
   
-  def create_invoice_payments    
-    # NOTE: Orders by oldest outstanding date first:
-    unpaid_invoices = Invoice.find_with_totals(
-      :all, 
-      :conditions => [
-        [
-        'client_id = ?',
-        'IF(activities_total.total_in_cents IS NULL, 0,activities_total.total_in_cents) - '+
-        'IF(invoices_total.total_in_cents IS NULL, 0,invoices_total.total_in_cents) > ?'
-         ].join(' AND '),
-        client_id, 
-        0
-      ]
-    )
-
-    current_client_balance = Money.new(0)
-    unpaid_invoices.each { |inv| current_client_balance += inv.amount_outstanding }
-    
-    currently_unallocated = amount_unallocated
-
-    unpaid_invoices.each do |unpaid_invoice|
-      break if currently_unallocated <= 0 or current_client_balance <= 0
-
-      payment_allocation = (currently_unallocated >= unpaid_invoice.amount_outstanding) ? 
-        unpaid_invoice.amount_outstanding : 
-        currently_unallocated
-      
-      InvoicePayment.create! :payment => self, :invoice => unpaid_invoice, :amount => payment_allocation
-
-      current_client_balance -= payment_allocation
-      currently_unallocated  -= payment_allocation
-    end
-  end
-  
-  def destroy_invoice_payments
-    InvoicePayment.destroy_all ['payment_id = ?', id]
-  end
-  
-  def amount_unallocated
-    (attribute_present? :amount_unallocated_in_cents) ? 
+  def amount_unallocated( force_reload = false )
+    (attribute_present? :amount_unallocated_in_cents  and !force_reload) ? 
       Money.new(read_attribute(:amount_unallocated_in_cents).to_i) : 
       (amount - amount_allocated)
   end
   
-  def amount_allocated
+  def amount_allocated( force_reload = false )
     Money.new(  
-      (attribute_present? :amount_allocated_in_cents) ? 
+      (attribute_present? :amount_allocated_in_cents  and !force_reload) ? 
         read_attribute(:amount_allocated_in_cents).to_i : 
         ( InvoicePayment.sum(:amount_in_cents, :conditions => ['payment_id = ?', id]) || 0 )
     )
   end
   
+  def is_allocated?( force_reload = false )
+    (attribute_present? :is_allocated  and !force_reload) ? 
+      (read_attribute(:is_allocated).to_i == 1) :
+      amount_unallocated(true).zero?
+  end
+  
+  def validate_invoice_payments_not_greater_than_amount    
+    my_amount = self.amount
+    assignment_amount = self.invoice_assignments.inject(Money.new(0)){|sum,ip| ip.amount+sum }
+    
+    # We use the funky :> /:< to differentiate between the case of a credit invoice and a (normal?) invoice
+    errors.add :invoice_assignments, "exceeds payment amount" if assignment_amount.send(
+      (my_amount >= 0) ? :> : :<, my_amount
+    )
+  end
+  
   def validate_on_update
     errors.add_to_base "Payments can't be updated after creation"
   end