brisk-bills 0.6.0

data/app/models/employee/slimtimer.rb

@@ -0,0 +1,43 @@
+class Employee::Slimtimer < ActiveRecord::Base
+   belongs_to  :employee
+   
+   has_many :owned_tasks, :class_name => 'SlimtimerTask', :foreign_key => :owner_employee_slimtimer_id
+   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
+
+   def slimtimer_api_key
+     slimtimer.api_key unless slimtimer.nil?
+   end
+ 
+   def slimtimer_username
+     slimtimer.username unless slimtimer.nil?
+   end
+
+   def slimtimer_password
+     slimtimer.password unless slimtimer.nil?
+   end
+
+   def slimtimer_api_key=(val)
+     build_slimtimer if slimtimer.nil?
+     
+     slimtimer.api_key = val
+   end
+
+   def slimtimer_username=(val)
+     build_slimtimer if slimtimer.nil?
+     
+     slimtimer.username = val
+   end
+
+   def slimtimer_password=(val)
+     build_slimtimer if slimtimer.nil?
+     
+     slimtimer.password = val
+   end
+
+end

data/app/models/employee_client_labor_rate.rb

@@ -0,0 +1,20 @@
+class EmployeeClientLaborRate < ActiveRecord::Base
+  include MoneyModelHelper
+  
+  belongs_to :client
+  belongs_to :employee
+  
+  validates_presence_of :client_id
+  validates_presence_of :employee_id  
+  
+  validates_numericality_of :hourly_rate, :greater_than_or_equal_to => 0, :message => "is not a valid monetary amount"
+  
+  validates_uniqueness_of :employee_id, :scope => :client_id, :message => "/ Client relationship is already defined"
+  
+  money :hourly_rate,  :currency => false
+  
+  def label
+    "%s : %s" % [self.employee.name,self.client.name]
+  end
+  
+end

data/app/models/invoice.rb

@@ -0,0 +1,280 @@
+class Invoice < ActiveRecord::Base
+  include ExtensibleObjectHelper
+  
+  # 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
+
+  belongs_to :client
+  has_many :activities, :dependent => :nullify
+  has_many :payments, :through => 'invoice_payments'
+  
+  has_and_belongs_to_many(
+    :activity_types, 
+    :join_table     => 'invoices_activity_types', 
+    :before_remove  => :invalid_if_published, 
+    :before_add     => :invalid_if_published,
+    :uniq => true
+  )
+  
+  validates_presence_of :client_id, :issued_on
+
+  # 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))'
+
+  def initialize(*args)
+    super(*args)
+    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
+  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
+    )
+  end
+  
+  def is_most_recent_invoice?
+    newest_invoice = Invoice.find :first, :select => 'id', :order => 'issued_on DESC', :conditions => ['client_id = ?', client_id]
+
+    (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"
+      return false
+    end
+  end
+  
+  def ensure_not_published_on_update
+    errors.add_to_base "Can't update a published invoice" if is_published and !changes.has_key? :is_published
+  end
+  
+  def validate_on_update
+    errors.add :client, "can't be updated after creation" if changes.has_key? "client_id"
+
+    errors.add_to_base(
+      "Invoice can't be updated once published."
+    ) if is_published and changes.reject{|k,v| k == 'is_published'}.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
+  end
+
+  def sub_total
+    process_total :sub_total, :cost_in_cents
+  end
+  
+  def amount( force_reload = false )
+    (attribute_present? :amount_in_cents  and !force_reload) ?
+      Money.new(read_attribute(:amount_in_cents).to_i) :
+      process_total( :amount, ACTIVITY_TOTAL_SQL )
+  end
+  
+  def grand_total
+    process_total :grand_total, ACTIVITY_TOTAL_SQL
+  end
+  
+  def name  
+    '"%s" Invoice on %s'  % [ (client) ? client.company_name : '(Unknown Client)', issued_on.strftime("%m/%d/%Y %I:%M %p") ]
+  end
+  
+  def long_name
+    "Invoice #%d (%s) - %s (%s)" % [
+      id,
+      issued_on.strftime("%m/%d/%Y %I:%M %p"),
+      client.company_name,
+      ('$%.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?
+
+    InvoicePayment.find(
+      :first,
+      :order => 'payments.paid_on DESC', 
+      :include => [:payment],
+      :conditions => ['invoice_id = ?', id]
+    ).payment.paid_on
+    
+    rescue
+      nil
+  end
+  
+  def is_paid?( force_reload = false )
+    (attribute_present? :is_paid  and !force_reload) ? 
+      (read_attribute(:is_paid).to_i == 1) :
+      amount_outstanding.zero?
+  end
+  
+  def amount_paid( force_reload = false )
+    Money.new( 
+      (attribute_present? :amount_paid_in_cents and !force_reload) ? 
+      read_attribute(:amount_paid_in_cents).to_i :
+      InvoicePayment.sum( :amount_in_cents, :conditions => ['invoice_id = ?', id] ).to_i
+    )
+  end
+  
+  def amount_outstanding
+    amount - amount_paid
+  end
+
+  def self.find_with_totals( how_many = :all, options = {} )
+    joins = []
+    joins << 'LEFT JOIN ('+
+      "SELECT invoices.id AS invoice_id, SUM(#{ACTIVITY_TOTAL_SQL}) AS total_in_cents"+
+      ' FROM invoices'+
+      ' LEFT JOIN activities ON activities.invoice_id = invoices.id'+
+      ' GROUP BY invoices.id'+
+    ') AS activities_total ON activities_total.invoice_id = invoices.id'
+    
+    joins << 'LEFT JOIN ('+
+      'SELECT invoices.id AS invoice_id, SUM(invoice_payments.amount_in_cents) AS total_in_cents'+
+      ' FROM invoices'+
+      ' LEFT JOIN invoice_payments ON invoice_payments.invoice_id = invoices.id'+
+      ' GROUP BY invoices.id'+
+    ') AS invoices_total ON invoices_total.invoice_id = invoices.id'
+
+    cast_amount = 'IF(activities_total.total_in_cents IS NULL, 0,activities_total.total_in_cents)'
+    cast_amount_paid = 'IF(invoices_total.total_in_cents IS NULL, 0,invoices_total.total_in_cents)'
+
+    Invoice.find( 
+      how_many,
+      {
+        :select => [
+          'invoices.id',
+          'invoices.client_id',
+          'invoices.comments',
+          'invoices.issued_on',
+          "#{cast_amount} AS amount_in_cents",
+          "#{cast_amount_paid} AS amount_paid_in_cents",
+          "#{cast_amount} - #{cast_amount_paid} AS amount_outstanding_in_cents"
+        ].join(', '),
+        :order => 'issued_on ASC',
+        :joins => joins.join(' ')
+      }.merge(options)
+    )
+  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
+  end
+
+  handle_extensions
+end

data/app/models/invoice_payment.rb

@@ -0,0 +1,8 @@
+class InvoicePayment < ActiveRecord::Base
+  include MoneyModelHelper
+  
+  belongs_to :payment
+  belongs_to :invoice
+  
+  money :amount, :currency => false
+end

data/app/models/notifier.rb

@@ -0,0 +1,85 @@
+class Notifier < ActionMailer::Base
+
+  def reset_password_requested( credential_name, credential_email, reset_token, host )
+    tmpl_parameters = {
+      :reset_token      => reset_token,
+      :credential_name  => credential_name,
+      :credential_email => credential_email,
+      :reset_password_url_for => {
+        :controller    => 'authentication', 
+        :action        => 'reset_password_via_token', 
+        :email_address => credential_email,
+        :token         => reset_token,
+        :only_path     => false,
+        :host          => host
+      }
+    }.merge common_tmpl_parameters
+
+    from       from_address(tmpl_parameters)
+    bcc        from_address(tmpl_parameters)
+    recipients '%s <%s>' % [credential_name, credential_email] 
+    subject    "%s - Password Reset Instructions" % tmpl_parameters[:company_name]
+    
+    generate_view_parts :reset_password_requested, tmpl_parameters
+  end
+
+  def invoice_available( invoice, client, payment_notice, attachments )
+    tmpl_parameters = {
+      :client => client,
+      :payment_notice => payment_notice
+    }.merge common_tmpl_parameters
+    
+    notifiers_bcc  = Setting.grab(:bcc_invoices_to)[0].split ','
+
+    representative_emails = client.client_representatives.collect{|cr| '%s <%s>' % [cr.name,cr.email_address]}
+    is_production = (RAILS_ENV == 'production')
+    
+    subject_line = "%s invoice %d (%s) now available"
+    subject_line += " | Intended Recipients: "+representative_emails.join(', ') unless is_production
+
+    # Here's the real deal
+    from       from_address(tmpl_parameters)
+    bcc        notifiers_bcc if is_production
+    recipients (is_production) ? representative_emails : from_address(tmpl_parameters)
+    subject    subject_line % [
+      tmpl_parameters[:company_name],
+      invoice.id,
+      invoice.issued_on.strftime('%m/%d/%Y'),
+      representative_emails.join(', ')
+    ]
+
+    generate_view_parts :invoice_available, tmpl_parameters
+
+    attachments.each { |attach_params| attachment attach_params }
+  end
+
+  private
+
+  def common_tmpl_parameters
+    tmpl = {}
+    setting_keys = %w(
+      site_admin_name site_admin_email company_logo_file company_name company_address1 company_address2
+      company_city company_state company_zip company_phone company_fax company_url
+    ).collect{|s| s.to_sym}
+
+    setting_vals = Setting.grab(*setting_keys)
+
+    0.upto(setting_keys.length-1){ |i| tmpl[setting_keys[i]] = setting_vals[i] }
+
+    tmpl
+  end
+
+  def from_address(tmpl)
+    '%s <%s>' % [ tmpl[:site_admin_name], tmpl[:site_admin_email] ]
+  end
+
+  def generate_view_parts(view_name, tmpl)
+    part( :content_type => "multipart/alternative" ) do |p|
+      [
+        { :content_type => "text/plain", :body => render_message("#{view_name.to_s}.plain.rhtml", tmpl) },
+        { :content_type => "text/html",  :body => render_message("#{view_name.to_s}.html.rhtml",  tmpl.merge({:part_container => p})) }
+      ].each { |parms| p.part parms.merge( { :charset => "UTF-8", :transfer_encoding => "7bit"} ) }
+    end
+  end
+
+end

data/app/models/payment.rb

@@ -0,0 +1,108 @@
+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'
+  
+  validates_presence_of :client_id, :payment_method_id
+  validates_numericality_of :amount, :allow_nil => false
+  
+  money :amount, :currency => false
+  
+  def initialize(*args)
+    super(*args)
+    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) ? 
+      Money.new(read_attribute(:amount_unallocated_in_cents).to_i) : 
+      (amount - amount_allocated)
+  end
+  
+  def amount_allocated
+    Money.new(  
+      (attribute_present? :amount_allocated_in_cents) ? 
+        read_attribute(:amount_allocated_in_cents).to_i : 
+        ( InvoicePayment.sum(:amount_in_cents, :conditions => ['payment_id = ?', id]) || 0 )
+    )
+  end
+  
+  def validate_on_update
+    errors.add_to_base "Payments can't be updated after creation"
+  end
+  
+  def name  
+    '%.2f Payment from %s'  % [ amount, client.company_name ]
+  end
+
+  def self.find_with_totals( how_many = :all, options = {} )
+    cast_amount_allocated = 'IF(payments_total.amount_allocated_in_cents IS NULL, 0, payments_total.amount_allocated_in_cents)'
+    
+    joins = 'LEFT JOIN ('+
+      'SELECT payment_id, SUM(amount_in_cents) AS amount_allocated_in_cents FROM invoice_payments GROUP BY payment_id'+
+    ') AS payments_total ON payments_total.payment_id = payments.id'
+    
+    Payment.find( 
+      how_many,
+      {
+        :select => [
+          'payments.id',
+          'payments.amount_in_cents',
+          "#{cast_amount_allocated} AS amount_allocated_in_cents",
+          "payments.amount_in_cents - #{cast_amount_allocated} AS amount_unallocated_in_cents"
+        ].join(', '),
+        :order => 'paid_on ASC',
+        :joins => joins,
+        :group => 'payments.id'
+      }.merge(options)
+    )
+  end
+  
+  handle_extensions
+end