brisk-bills 0.6.0

data/app/helpers/extensible_object_helper.rb

@@ -0,0 +1,28 @@
+require 'find'
+
+module ExtensibleObjectHelper 
+  
+  def self.append_features(base) # :nodoc:
+    super
+    base.extend ClassMethods
+  end
+  
+  module ClassMethods
+
+    def handle_extensions      
+      /^(#{BRISKBILLS_ROOT}.+)\.rb\:[\d]+/.match caller[0]
+      
+      extension_directory = $1
+      
+      Find.find(extension_directory) do |f| 
+        # Don't traverse sub-directories:
+        Find.prune if f != extension_directory and File.directory?(f)
+
+        require_dependency f if /#{extension_directory}\/.+\.rb$/.match f 
+      end if File.directory? extension_directory
+      
+    end    
+
+  end
+  
+end

data/app/helpers/has_credential_model_helper.rb

@@ -0,0 +1,39 @@
+module HasCredentialModelHelper 
+  
+  %w(email_address password password_hash login_enabled).each do |accessor|
+    define_method accessor.to_sym do      
+      credential.send accessor.to_sym if credential
+    end
+    
+    setter_method = "#{accessor}=".to_sym
+    
+    define_method setter_method do |val|
+      build_credential unless credential
+
+      credential.send setter_method, val
+    end
+  end
+
+  def credential_after_save
+    credential.save! if credential.changed?
+  end
+
+  def validate_credential_fields
+    credential.errors.each{|attr,msg| errors.add attr, msg } unless credential.valid?
+    validate_without_credentials
+  end
+
+  def self.append_features(base)
+    super
+
+    base.class_eval do
+      has_one :credential, :as => :user, :dependent => :destroy
+      
+      after_save :credential_after_save
+      
+      
+      alias validate_without_credentials validate
+      alias validate validate_credential_fields
+    end
+  end  
+end

data/app/helpers/invoice_pdf_helper.rb

@@ -0,0 +1,71 @@
+module InvoicePdfHelper #:nodoc:
+  
+  
+end
+
+# This let's us add the on_start_new_page functionality in the PDF::Writer library
+
+class SerializableProc #:nodoc:
+   def self._load( proc_string )
+   new(proc_string)
+   end
+
+   def initialize( proc_string )
+   @code = proc_string
+   @proc = nil
+   end
+
+   def _dump( depth )
+   @code
+   end
+
+   def method_missing( method, *args )
+   if to_proc.respond_to? method
+   @proc.send(method, *args)
+   else
+   super
+   end
+   end
+
+   def to_proc( )
+   return @proc unless @proc.nil?
+
+   if @code =~ /\A\s*(?:lambda|proc)(?:\s*\{|\s+do).*(?:\}|end)\s*\Z/
+   @proc = eval @code
+   elsif @code =~ /\A\s*(?:\{|do).*(?:\}|end)\s*\Z/
+   @proc = eval "lambda #{@code}"
+   else
+   @proc = eval "lambda { #{@code} }"
+   end
+   end
+
+   def to_yaml( )
+   @proc = nil
+   super
+   end
+end
+
+module PDF #:nodoc:
+  class Writer #:nodoc:
+    unless method_defined? :start_new_page_without_callback
+      def on_start_new_page(run_now , serializable_exec)
+        @on_start_new_page = serializable_exec
+        @on_start_new_page.to_proc.call self if run_now
+      end
+  
+      alias start_new_page_without_callback start_new_page
+  
+      def start_new_page(*args)
+        new_page_proc = @on_start_new_page.to_proc unless @on_start_new_page.nil? or !@on_start_new_page.respond_to?(:to_proc)
+  
+        # This first one is a little ghetto... would be nice if it were actually called on the first page
+        #new_page_proc.call self if current_page_number == 1 and new_page_proc
+        ret = start_new_page_without_callback(*args)
+  
+        new_page_proc.call self if new_page_proc
+  
+        ret
+      end
+    end
+  end
+end

data/app/helpers/is_active_model_helper.rb

@@ -0,0 +1,40 @@
+module IsActiveModelHelper 
+
+
+  def initialize(*args)
+    super(*args)
+    
+    is_active = true if new_record?
+  end
+  
+  def self.append_features(base)
+    super
+    
+    base.class_eval do
+      def self.find_active(*args)
+        args[1] ||= {}
+    
+        conditions = args[1][:conditions]
+    
+        if conditions.class == String
+          conditions = ['is_active = ? AND '+conditions,true]
+        elsif (
+          conditions.respond_to?(:length) and 
+          conditions.length > 0 and 
+          conditions[0].class == String and 
+          conditions[0].length > 0
+        )
+          conditions = [ 'is_active = ? AND '+conditions[0], true ] + conditions[1..conditions.length]
+        else
+          conditions = [ 'is_active = ?', true ]
+        end
+    
+        args[1][:conditions] = conditions
+    
+        self.find(*args)
+      end 
+      
+    end
+  end
+  
+end

data/app/helpers/money_model_helper.rb

@@ -0,0 +1,21 @@
+module MoneyModelHelper
+  # THis module provides assistance to models which utilize the rails_money gem
+  
+  def self.append_features(base)
+    super
+    
+    base.class_eval do
+      super
+      
+      # This prevents a NoMethodError: undefined method `amount_before_type_cast' error when validations kick-in
+      def method_missing(symbol, *params)
+        if (symbol.to_s =~ /^(.*)_before_type_cast$/)
+         send $1
+        else
+         super
+        end
+      end
+      
+    end
+  end
+end

data/app/model_views/client_accounting.rb

@@ -0,0 +1,5 @@
+class ClientAccounting < Client
+  # NOTE: I really hate that I have to create a model, this way, but, it seems to work ok ...
+  
+  self.table_name = 'clients_with_balances'
+end

data/app/model_views/client_financial_transaction.rb

@@ -0,0 +1,15 @@
+class ClientFinancialTransaction < ActiveRecord::Base
+  # NOTE: This whole thing is kind of a hack...
+  # We're not a *real* model, we're just an ActiveRecord class around a view thats useful 
+  self.table_name = 'client_finance_transactions'
+
+  belongs_to :client
+
+  def amount
+    Money.new read_attribute(:amount_in_cents).to_i
+  end
+
+  def readonly?
+    true
+  end
+end

data/app/model_views/invoices_with_total.rb

@@ -0,0 +1,36 @@
+class InvoicesWithTotal < Invoice
+  # NOTE: I really hate that I have to create a wrapper-model this way, but, it seems to work ok for now I guess ...
+  # Maybe I could put this into a plugin or something ... let's see
+  # Or even just taking these out of the models folder would be great, maybe even into the controller's .rb
+  # This is a little too crappy, but, whatev for now ...
+
+  self.table_name = 'invoices_with_totals'
+
+  def create(*args)    
+    invoice_assign_and_save! Invoice.new
+  end
+  
+  def update
+    invoice_assign_and_save! Invoice.find(id)
+  end
+  
+  def destroy
+    inv = Invoice.find(id)
+    inv.destroy
+  end
+  
+  def invoice_assign_and_save!(inv)
+    invoice_columns = Invoice.columns.collect{|c| c.name}-['id']
+
+    inv.activity_type_ids = activity_type_ids
+    
+    attributes.reject{|k,v| true unless invoice_columns.include? k }.each{ |k,v| inv.send "#{k}=", v }
+
+    inv.save!
+
+    inv.errors.each { |attr,msg| errors.add attr, msg }
+    
+    inv
+  end
+
+end

data/app/models/activity.rb

@@ -0,0 +1,104 @@
+class Activity < ActiveRecord::Base
+  include ExtensibleObjectHelper
+  include MoneyModelHelper
+
+  money :cost, :currency => false
+  money :tax,  :currency => false
+  
+  belongs_to :client
+  belongs_to :invoice
+  
+  validates_presence_of :activity_type
+  
+  # Since we've switched to acts_as_money, these two validations are no longer needed, since acts_as money guarantee's
+  # the nmericality... But - they don't hurt, so I'll keep them here.
+  validates_numericality_of :cost, :allow_nil => true
+  validates_numericality_of :tax,  :allow_nil => true
+  
+  before_destroy :ensure_not_published
+  
+  def initialize(*args)
+    super(*args)
+  end
+  
+  def label
+    (self.activity_type.nil? or self.activity_type.length == 0) ? "Activity" : self.activity_type.capitalize
+  end
+  
+  attr_accessor :dont_validate_type_associations
+  def validate
+    activity_type_sym = (activity_type.nil? or activity_type.empty?) ? nil : activity_type.to_sym
+    
+    unless dont_validate_type_associations or !self.class.reflections.has_key?(activity_type_sym)
+      type_association = instance_variable_get("@#{activity_type}")
+
+      if type_association.nil?
+        errors.add activity_type_sym, 'missing'
+      else
+        type_association.valid?
+        type_association.errors.each { |attr,msg| errors.add attr, msg }
+      end
+
+    end
+  end
+
+  before_save do |record| 
+    activity_type_sym = (record.activity_type.nil? or record.activity_type.empty?) ? nil : record.activity_type.to_sym
+    
+    if record.class.reflections.has_key?(activity_type_sym)
+      type_association = record.send activity_type_sym
+    
+      type_association.save if type_association and type_association.changed?
+    end
+  end
+  
+  def is_paid?
+    (invoice.nil?) ? false : invoice.is_paid?
+  end
+  
+  def is_published?
+    (invoice.nil?) ? false : invoice.is_published
+  end
+  
+  def ensure_not_published
+    if is_published?
+      errors.add_to_base "Can't destroy an activity once its invoice is published"
+      return false
+    end
+  end
+  
+  def validate_on_update
+    errors.add_to_base "Activity can't be adjusted once its invoice is published" if is_published? and changed_attributes.length > 0 
+  end
+  # /No updates/destroys
+  
+  def sub_activity
+    send activity_type unless activity_type.nil?
+  end
+  
+  def authorized_for?(options)
+    case options[:action].to_s
+      when /^(update|destroy)$/
+        (is_published?) ? false : true
+      else
+        true
+    end
+  end
+  
+  def move_to_invoice(dest)        
+    dest_invoice = (dest.class == Integer) ? Invoice.find(dest) : dest
+
+    raise StandardError, "Can't move an already-published activity." if is_published?
+    raise StandardError, "Can't move an activity to an already published invoice." if dest_invoice.is_published?
+
+    self.invoice_id = dest_invoice.id
+    self.client_id = dest_invoice.client_id
+    
+
+    @dont_validate_type_associations = true
+    save!
+    @dont_validate_type_associations = false
+  end
+  
+  handle_extensions
+end

data/app/models/activity/adjustment.rb

@@ -0,0 +1,34 @@
+class Activity::Adjustment < ActiveRecord::Base
+  include ExtensibleObjectHelper
+  include ActivityTypeModelHelper
+  
+  validates_presence_of :label
+  
+  def name
+    type_quick_namer '%s for %s on %s', label, client
+  end
+
+  def as_legacy_ledger_row
+    
+    if label and comments and label.length > 0 and comments.length > 0
+      description = '%s - %s' % [label, comments]
+    else
+      description = (comments and comments.length > 0) ? comments : label
+    end
+    
+    [
+    1,
+    activity.cost,
+    activity.cost,
+    'Adjustment',
+    occurred_on.strftime('%m/%d/%y'),
+    description.tr("\r\n", '')
+    ]
+  end
+
+  handle_extensions
+end
+
+Activity.class_eval do
+  has_one :adjustment, :class_name => 'Activity::Adjustment', :dependent => :destroy, :foreign_key => :activity_id
+end

data/app/models/activity/labor.rb

@@ -0,0 +1,91 @@
+class Activity::Labor < ActiveRecord::Base
+  include ExtensibleObjectHelper
+  
+  def initialize(*args)
+    # NOTE: This must be declared before the ActivityTypeModelHelper
+    super(*args)
+    self.minute_duration = 0 if minute_duration.nil?
+  end
+  
+  include ActivityTypeModelHelper
+
+  belongs_to :employee, :class_name => "::Employee"
+
+  validates_presence_of :employee_id
+  validates_numericality_of :minute_duration, :allow_nil => false
+    
+  validate :validate_duration
+
+  def validate_duration
+    errors.add :duration, 'invalid' if !@duration.nil? and self.minute_duration != @duration
+  end
+    
+  def name
+    type_quick_namer '%s at %s on %s', employee, client
+  end
+
+  def duration=(val)
+    val = val.to_s unless val.class.name == 'String'
+
+    self.minute_duration = @duration = case val
+      # 40, 40m
+      when /^[ ]*([\d]+)[ ]*[m]?[ ]*$/ then $1.to_i
+      # 1h, 1hr
+      when /^[ ]*([\d]+)[ ]*(h|hr)[ ]*$/ then $1.to_i*60
+      # 1h 40m, 1 40, 1:15
+      when /^[ ]*([\d]+)[ ]*(?:hr|[h\:]?)[ ]*([\d]{1,2})[ ]*[m]?[ ]*$/ then $1.to_i*60+$2.to_i
+      # empty string?
+      when /^[ ]*$/ then 0
+
+      else raise StandardError
+    end
+  
+    rescue 
+      @duration = val
+  end
+
+  def friendly_duration
+    hour = (self.minute_duration / 60).floor
+    min  = (self.minute_duration % 60).round
+   
+    (hour > 0) ? sprintf( "%dhr %dmin", hour, min ) : "#{min}min"
+    rescue
+      ""
+  end
+  
+  def clock_duration
+    "%02d:%02d" % [ (minute_duration/60).floor, (minute_duration % 60).round ] unless minute_duration.nil?
+  end
+  
+  alias duration clock_duration
+  
+  def as_legacy_ledger_row
+
+    begin
+      hourly_rate = '%.2f' % employee.labor_rate_for(activity.client).hourly_rate.to_f
+    rescue
+      hourly_rate = ' '
+    end
+    
+    begin
+      item_name = 'Labor-'+employee.short_name
+    rescue
+      item_name = 'Labor'
+    end
+    
+    [
+    '%.2fhr' % (minute_duration.to_f/60),
+    hourly_rate,
+    '%.2f' % activity.cost.to_f,
+    item_name,
+    occurred_on.strftime('%m/%d/%y'),
+    comments.tr("\r\n", '')
+    ]
+  end
+
+  handle_extensions
+end
+
+Activity.class_eval do
+  has_one :labor, :class_name => 'Activity::Labor', :dependent => :destroy, :foreign_key => :activity_id
+end