brisk-bills 0.7.0 → 0.8.1

data/app/models/client.rb

@@ -21,9 +21,11 @@ class Client < ActiveRecord::Base
   end
   
   def uninvoiced_activities_balance( force_reload = false )
-    (attribute_present? :uninvoiced_activities_balance_in_cents and !force_reload) ?
-      Money.new(read_attribute(:uninvoiced_activities_balance_in_cents).to_i) :
-      (Activity.sum( Invoice::ACTIVITY_TOTAL_SQL, :conditions => ['client_id = ? AND is_published = ? AND invoice_id IS NULL',id, true] ) or 0)
+    Money.new(
+      (attribute_present? :uninvoiced_activities_balance_in_cents and !force_reload) ?
+        read_attribute(:uninvoiced_activities_balance_in_cents).to_i :
+        Activity.sum( Invoice::ACTIVITY_TOTAL_SQL, :conditions => ['client_id = ? AND is_published = ? AND invoice_id IS NULL',id, true] ).to_i
+    )
   end
   
   # THis is the client's outstanding balance. This value is calculated based off the total invoices amount - total payments amount. And is 
@@ -62,12 +64,17 @@ class Client < ActiveRecord::Base
   end
   
   def ensure_not_referenced_on_destroy
-    errors.add_to_base "Can't destroy a referenced employee" and return false unless authorized_for? {:destroy}
+    unless authorized_for?(:action => :delete)
+      errors.add_to_base "Can't destroy a referenced employee"
+      return false
+    end
   end
   
   def authorized_for?(options)
-    case options[:action]
-      when :destroy
+    return true unless options.try(:[],:action)
+    
+    case options[:action].to_sym
+      when :delete
         [Invoice, Payment, Activity].each{ |k| return false if k.count(:all, :conditions => ['client_id = ?', id] ) > 0 }
 
         true
@@ -123,7 +130,7 @@ class Client < ActiveRecord::Base
   # Returns an array of unsaved InvoicePayment objects, with unset invoice_ids, and 'recommended' amounts.
   # If the provided amount exactly equals an payment's unalloated amount, we return a InvoicePayment for the oldest such matching payment. 
   # Otherwise, we start applying the amount to payments in ascending order by issued_date.
-  def recommend_payment_assignments_for(amount, verbose_inclusion = false)
+  def recommend_payment_assignments_for(amount)
     amount = amount.to_money
     
     pymnts = unassigned_payments(
@@ -180,4 +187,24 @@ class Client < ActiveRecord::Base
     )
   end
 
-end
+  # This is mostly used by the batch create feature. Here, we return an array of clients, which have approved,
+  # unassigned activity which occurred before the specified_date
+  def self.find_invoiceable_clients_at(occurred_at)
+    find(
+      :all,
+      :select     => 'DISTINCT `clients`.*',
+      :joins      => 'LEFT JOIN `activities` ON `clients`.id = `activities`.client_id',
+      :conditions => [
+        [
+          '`activities`.occurred_on <= ?',
+          '`activities`.is_published = ?',
+          '`activities`.invoice_id IS NULL'
+        ].join(" AND "),
+        occurred_at, 
+        true
+      ],
+      :order => ["`clients`.company_name ASC","`clients`.id ASC"].join(",")
+    )
+  end
+
+end

data/app/models/client_representative.rb

@@ -10,21 +10,13 @@ class ClientRepresentative < ActiveRecord::Base
   )
   
   def name
-    ret = String.new
-    
-    ret += self.first_name if !self.first_name.nil? and self.first_name.length > 0
-    
-    ret += (ret.length > 0) ? " #{self.last_name}" : self.last_name if !self.last_name.nil? and self.last_name.length > 0
-    
-    ret
+    [
+      first_name, last_name
+    ].find_all{|x| x.try(:length).try(:>,0)}.join(' ')
   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)
+  # This is used by the Nested Add_existing control label
+  def self.human_name
+    'Representative'
   end
-
-
 end

data/app/models/credential.rb

@@ -23,7 +23,7 @@ class Credential < ActiveRecord::Base
     begin
       @salt = Rails.configuration.authentication_salt
     rescue
-      @salt = "Salt is missing - No Salt is a bad idea!"
+      @salt = t(:salt_is_missing)
       logger.error @salt # cheeky?
     end unless @salt
 

data/app/models/employee.rb

@@ -15,13 +15,9 @@ class Employee < ActiveRecord::Base
   validates_numericality_of :phone_extension, :allow_nil => true
 
   def name
-    ret = String.new
-    
-    ret += first_name if !first_name.nil? and first_name.length > 0
-    
-    ret += (ret.length > 0) ? " #{last_name}" : last_name if !last_name.nil? and last_name.length > 0
-    
-    ret
+    [
+      first_name, last_name
+    ].find_all{|x| x.try(:length).try(:>,0)}.join(' ')
   end
 
   def short_name
@@ -33,16 +29,18 @@ class Employee < ActiveRecord::Base
   end
   
   def ensure_not_referenced_on_destroy
-    ( errors.add_to_base "Can't destroy a referenced employee" and return false ) unless authorized_for? :action => :destroy
+    ( errors.add_to_base "Can't destroy a referenced employee" and return false ) unless authorized_for? :action => :delete
   end
 
   def authorized_for?(options)
-    case options[:action]
-      when :destroy
+    return true unless options.try(:[],:action)
+    
+    case options[:action].to_sym
+      when :delete
         ( Activity::Labor.count( :all, :conditions => ['employee_id = ?', id] ) > 0 ) ? false : true
       else
         true
-    end
+    end 
   end
 
   # There were some issues in rails 2.3.2 that caused associations (slimtimer/credential/etc) to not save without this hack

data/app/models/invoice.rb

@@ -11,7 +11,7 @@ class Invoice < ActiveRecord::Base
 
   belongs_to :client
   has_many :activities, :dependent => :nullify
-  has_many :payments, :through => :assigned_payments
+  has_many :payments, :through => :payment_assignments
   has_many :payment_assignments, :class_name => 'InvoicePayment', :dependent => :delete_all
   
   has_and_belongs_to_many(
@@ -31,7 +31,7 @@ class Invoice < ActiveRecord::Base
 
   def initialize(*args)
     super(*args)
-    end_of_last_month = Time.utc(*Time.now.to_a).last_month.end_of_month
+    end_of_last_month = Time.utc(*Time.now.to_a).prev_month.end_of_month
     self.issued_on = end_of_last_month unless self.issued_on
   end
   
@@ -78,8 +78,12 @@ class Invoice < ActiveRecord::Base
   end
 
   def authorized_for?(options)
-    case options[:action].to_s
-      when /^(destroy)$/
+    return true unless options.try(:[],:action)
+    
+    case options[:action].to_sym
+      when :delete
+        !is_published
+      when :edit
         !is_published
       else
         true
@@ -107,7 +111,7 @@ class Invoice < ActiveRecord::Base
   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") ]
+    '%s Invoice on %s'  % [ (client) ? client.company_name : '(Unknown Client)', issued_on.strftime("%m/%d/%Y %I:%M %p") ]
   end
   
   def long_name
@@ -120,7 +124,7 @@ class Invoice < ActiveRecord::Base
   end
   
   def paid_on
-    raise StandardError unless is_paid?
+    raise StandardError unless is_paid?(true)
 
     InvoicePayment.find(
       :first,
@@ -136,21 +140,21 @@ 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(true) <= 0
+      amount_outstanding(force_reload) <= 0
   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
+      (payment_assignments(force_reload).collect(&:amount_in_cents).sum  || 0)
     )
   end
   
   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))
+      (amount(force_reload) - amount_paid(force_reload))
   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

data/app/models/invoice_payment.rb

@@ -16,7 +16,7 @@ class InvoicePayment < ActiveRecord::Base
   end
   
   def label
-    '%s @ (Invoice %d, Payment %d)' % [amount.format, invoice.id,payment.id,  ]
+    '%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.

data/app/models/notifier.rb

@@ -76,8 +76,8 @@ class Notifier < ActionMailer::Base
   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})) }
+        { :content_type => "text/plain", :body => render_message("#{view_name.to_s}.plain.erb", tmpl) },
+        { :content_type => "text/html",  :body => render_message("#{view_name.to_s}.html.erb",  tmpl.merge({:part_container => p})) }
       ].each { |parms| p.part parms.merge( { :charset => "UTF-8", :transfer_encoding => "7bit"} ) }
     end
   end

data/app/models/payment.rb

@@ -5,13 +5,21 @@ class Payment < ActiveRecord::Base
   belongs_to :client
   belongs_to :payment_method
   
-  has_many :invoices, :through => :assigned_payments
-  has_many :invoice_assignments, :class_name => 'InvoicePayment', :dependent => :delete_all
+  has_many :invoices, :through => :invoice_assignments
+  
+  # We have to make sure this doesnt validate since :amount_not_greater_than_payment_or_invoice_totals ,
+  # will trip things up if we're in the processing of manipulating invoice_assignments on payment that 
+  # already has some assignments
+  has_many :invoice_assignments, :class_name => 'InvoicePayment', :dependent => :delete_all, :validate =>false, :autosave => true
   
   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
+
+  validate :validate_invoice_payments_not_greater_than_invoice_amount
+  validate :validate_invoice_payments_only_assigned_to_published_invoices
+  validate :validate_invoice_payments_not_negative
     
   money :amount, :currency => false
   
@@ -23,21 +31,21 @@ class Payment < ActiveRecord::Base
   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)
+      (amount(force_reload) - amount_allocated(force_reload))
   end
   
   def amount_allocated( force_reload = false )
     Money.new(  
       (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 )
+        ( invoice_assignments(force_reload).collect(&:amount_in_cents).sum || 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?
+      amount_unallocated(force_reload).zero?
   end
   
   def validate_invoice_payments_not_greater_than_amount    
@@ -50,12 +58,48 @@ class Payment < ActiveRecord::Base
     )
   end
   
+  def validate_invoice_payments_not_greater_than_invoice_amount
+    invoice_assignments.each do |asgn|
+      errors.add(
+        :invoice_assignments, 
+        "has an invalid assignment whose amount (%s) is greater than invoice #%d's amount (%s)" % [
+          asgn.amount.to_s,
+          asgn.invoice.id,
+          asgn.invoice.amount.to_s
+        ]
+      ) if asgn.amount > asgn.invoice.amount
+    end
+  end
+  
+  def validate_invoice_payments_only_assigned_to_published_invoices
+    invoice_assignments.each do |asgn|
+      errors.add(
+        :invoice_assignments, 
+        "has an invalid assignment which is applied to an unpublished invoice #%d" % [
+          asgn.invoice.id
+        ]
+      ) unless asgn.invoice.is_published
+    end
+  end
+  
+  def validate_invoice_payments_not_negative
+    invoice_assignments.each do |asgn|
+      errors.add(
+        :invoice_assignments, 
+        "has an invalid assignment with a negative value applied to invoice #%d" % [
+          asgn.invoice.id
+        ]
+      ) if asgn.amount < 0
+    end
+  end
+  
+  # We don't want any actual fields changing on update. But, we do want the assignments to be changeable... 
   def validate_on_update
-    errors.add_to_base "Payments can't be updated after creation"
+    errors.add_to_base "Payments can't be updated after creation" if changed.length > 0
   end
   
   def name  
-    '%.2f Payment from %s'  % [ amount, client.company_name ]
+    '%s Payment from %s'  % [ amount.format, client.company_name ]
   end
 
   def self.find_with_totals( how_many = :all, options = {} )

data/app/models/setting.rb

@@ -33,7 +33,9 @@ class Setting < ActiveRecord::Base
   end
   
   def authorized_for?(options)
-    (options[:action] == :destroy) ? false : true
+    return true unless options.try(:[],:action)
+    
+    (options[:action].to_sym != :delete)
   end
   
 end

data/app/views/active_scaffold_overrides/add_existing.js.rjs

@@ -0,0 +1,25 @@
+# NOTE: We overide this templayte b/c it seems as if there's a bug in active scaffold
+# that causes nested forms to always stay open after submit. We didn't want that, so
+# this version is only slightly different than the dist
+page.insert_html :top, active_scaffold_tbody_id, :partial => 'list_record', :locals => {:record => @record}
+page.replace active_scaffold_calculations_id, :partial => 'list_calculations' if active_scaffold_config.list.columns.any? {|c| c.calculation?}
+page << "ActiveScaffold.stripe($('#{active_scaffold_tbody_id}'))"
+page << "ActiveScaffold.hide_empty_message('#{active_scaffold_tbody_id}','#{empty_message_id}');"
+page << "ActiveScaffold.increment_record_count('#{active_scaffold_id}');"
+logger.error "HMM : #{element_form_id(:action => :new_existing)}"
+# Modified
+form_stays_open = nil
+if (form_stays_open)
+# /Modified
+  # why not just re-render the form? that wouldn't utilize a possible do_new override which sets default values.
+  page << "$('#{element_form_id}').reset()"
+  page.replace_html element_messages_id(:action => :add_existing), :partial => 'form_messages'
+  # have to delay the focus, because there's no "firstElement" in prototype until at least one element is not disabled
+  page.delay 0.1 do
+    page << "Form.focusFirstElement('#{element_form_id}');"
+  end
+else
+  # Modified
+  page << "$$('##{element_form_id(:action => :add_existing)} a.cancel').first().link.close();"
+  # /Modified
+end

data/app/views/admin/activities/_adjustment_column.html.erb

@@ -0,0 +1,10 @@
+<ul class="activity_show  activity_adjustment_show">
+	<li class="type">Adjustment</li>
+	<li class="client"><%=h (record.client.nil?) ? '(Unknown)' : record.client.company_name %></li>
+	<% if record.adjustment -%>
+	<li class="label"><%=h record.adjustment.label %></li>
+	<% if record.adjustment.comments and record.adjustment.comments.length > 0 -%>
+	<li class="comments"><%=h record.adjustment.comments %></li>
+	<% end -%>
+	<% end -%>
+</ul>

data/app/views/admin/activities_with_prices/{move_to_invoice.rhtml → move_to_invoice.html.erb}

@@ -28,14 +28,14 @@
       <%= select_tag(
          'move_to_invoice_id', 
          options_for_select(
-           @dest_invoices.collect{|inv| [inv.long_name, inv.id]},
+           [['(None)', nil]]+@dest_invoices.collect{|inv| [inv.long_name, inv.id]},
            params[:move_to_invoice_id].to_i
          )
       ) %>
    <% else -%>
       <p class="warning-message">We're sorry, but no un-published invoices were available in the database for this move.</p>
    <% end -%>
-   <p>This activity's client and invoice association will be matched with the selected destination.</p>
+   <p>This activity's client and invoice association will be matched with the selected destination. If "(None)" is selected, this actvity will be removed from its current invoice, and placed back in the unassigned activity queue.</p>
    <p>
       <%= submit_tag 'Move...', :class => "MB_focusable" %>
        or 

data/app/views/admin/activities_with_prices/move_to_invoice.js.rjs

@@ -0,0 +1,5 @@
+if @errors_during_move.length > 0
+  page.alert @errors_during_move.to_s
+else
+  page.replace_html active_scaffold_content_id, :partial => 'list'
+end

data/app/views/admin/draft_invoices/batch_create.html.erb

@@ -0,0 +1,73 @@
+<div class="active-scaffold">
+  <div class="batch_create-view <%= "#{params[:controller]}-view" %> view">
+    <%= form_remote_tag(
+      :url      => url_for(:action => :batch_create),
+      :after    => [
+        "$('#{loading_indicator_id(:action => :batch_create)}').style.visibility = 'visible'",
+        "Form.disable('#{element_form_id(:action => :batch_create)}')"
+      ].join(';'),
+      :complete => [
+        "$('#{loading_indicator_id(:action => :batch_create)}').style.visibility = 'hidden'",
+        "Form.enable('#{element_form_id(:action => :batch_create)}')"
+      ].join(';'),
+      :failure  => "ActiveScaffold.report_500_response('#{active_scaffold_id}')",
+      :html => {
+        :href     => url_for(:action => :batch_create),
+        :onsubmit => onsubmit,
+        :id       => element_form_id(:action => :batch_create),
+        :class    => 'create'
+      }
+    ) %>
+    <h4>Batch Create</h4>
+    <div id="<%= element_messages_id(:action => :create) %>" class="messages-container"></div>
+
+    <ol class="form">
+    <li>
+    <p>Batch Create will automatically create unpublished invoices for the below specified clients. Invoices
+    will be populated with all the approved, unassigned activity in their queue, which occured on or before the specified date.</p>
+    </li>
+    <li class="form-element required">
+      <dl>
+        <dt><label>Invoice Date</label></dt>
+        <dd>
+        <% invoice_date_at_fields = [:year, :month, :day, :hour, :minute, :second] %>
+          <%=select_datetime(
+            @invoice_date_at, 
+            :prefix             => 'batch_invoice_date_at', 
+            :datetime_separator => ' — ', 
+            :time_separator     => ' : ',
+            :include_seconds    => true
+          ) %>
+          <%= invoice_date_at_fields.collect{|field_id| 
+            observe_field(
+              'batch_invoice_date_at_%s' % field_id, 
+              :url => url_for(:action => :batch_create_on_date_change), 
+              :with => invoice_date_at_fields.collect{|f|
+                "'batch_invoice_date_at[%s]='+$F('batch_invoice_date_at_%s')" % ([f]*2)
+              }.compact.join("+'&'+"),
+              :update => 'batch_invoice_clients_list'
+            )
+          }.join %>
+        </dd>
+      </dl>
+    </li>
+    <li class="form-element required">
+      <dl>
+        <dt><label>Clients</label></dt>
+        <dd><%= batch_create_clients_form_column @invoice_date_at %></dd>
+      </dl>
+    </li>
+    </ol>
+
+    <p class="form-footer">
+    <%= submit_tag "Batch Create", :class => "submit" %>
+    <%= link_to as_(:cancel), main_path_to_return, :class => 'cancel' %>
+    <%= loading_indicator_tag(:action => :batch_create) %>
+    </p>
+
+    </form>
+    <script type="text/javascript">
+    Form.focusFirstElement('<%= element_form_id(:action => :batch_create) -%>');
+    </script>
+  </div>
+</div>