brisk-bills 0.6.0

data/test/unit/notifier_test.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class NotifierTest < ActionMailer::TestCase
+  tests Notifier
+  # replace this with your real tests
+  def test_truth
+    assert true
+  end
+end

data/test/unit/payment_method_test.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class PaymentMethodTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/test/unit/payment_test.rb

@@ -0,0 +1,155 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/../test_unit_factory_helper.rb'
+
+class PaymentTest < ActiveSupport::TestCase
+
+  fixtures :activity_types
+
+  def test_payment_allocations
+    client = Factory.create_client
+
+    invoices = []
+    
+    [1200.00, 400, 99.99, 1500.99, 430.01].each do |amt| 
+      inv =  Factory.generate_invoice(amt)
+      
+      assert_equal amt, inv.amount # THis was a weird bug we were having so I put this here...
+      
+      invoices << inv
+    end
+
+    assert_equal 3630.99, client.balance
+    
+    payments = []
+    
+    [1200.00, 400.00, 99.99, 0.99, 1500, 400.0, 30.01].each do |amt|
+      payments << Factory.generate_payment(amt)
+    end
+    
+    assert_equal 0.to_money, client.balance
+    
+    payments.delete_at(1).destroy
+    
+    assert_equal 400.00.to_money, client.balance
+    
+    invoices.each_index { |i| assert_equal( ((i == 1) ? false : true), invoices[i].is_paid? ) }
+    
+    payments << Factory.generate_payment(174.00)
+    payments << Factory.generate_payment(15.00)
+    payments << Factory.generate_payment(10.00)
+    payments << Factory.generate_payment(201.00)
+    
+    assert_equal 0.0.to_money, client.balance
+    
+    assert_equal true, invoices[1].is_paid?
+    
+    payments << Factory.generate_payment(300.20)
+    
+    assert_equal -300.20.to_money, client.balance
+
+    invoices << Factory.generate_invoice(300.20)
+    
+    assert_equal 0.to_money, client.balance
+  end
+  
+  def test_invoice_allocates_payment_credits
+    client = Factory.create_client
+
+    Factory.generate_payment 230.00
+    Factory.generate_payment 70.00
+    
+    invoice_one = Factory.generate_invoice 290.00, :is_published => true
+
+    assert_equal true, invoice_one.is_paid? 
+    assert_equal -10.00, client.balance
+    
+    Factory.generate_payment 200.00
+    
+    invoice_two = Factory.generate_invoice 220.00, :is_published => true
+
+    assert_equal false, invoice_two.is_paid?
+    assert_equal 10.00, client.balance
+    
+    Factory.generate_payment 10.00
+    
+    assert_equal true, invoice_two.is_paid?
+    assert_equal 0.00, client.balance
+    
+    Factory.generate_payment 300.00
+    
+    invoice_three = Factory.generate_invoice 300.00, :is_published => true
+    
+    assert_equal true, invoice_three.is_paid?
+    assert_equal 0.00, client.balance
+  end
+
+  def test_invoice_paid_on
+    payment_one_on =  sanitize_time(Time.now - 3.months)
+    payment_two_on =  sanitize_time(Time.now - 2.months)
+    payment_three_on =  sanitize_time(Time.now - 2.months)
+    
+    Factory.generate_payment 200.00, :paid_on => payment_one_on
+
+    invoice = Factory.generate_invoice 600.00, :issued_on => payment_two_on,  :is_published => true
+    
+    payment_two = Factory.generate_payment 200.00, :paid_on => payment_two_on
+    Factory.generate_payment 200.00, :paid_on => payment_three_on
+
+    assert_equal true, invoice.is_paid?
+    assert_equal payment_two_on, invoice.paid_on
+    
+    payment_two.destroy
+    
+    assert_equal false, invoice.is_paid?
+    assert_equal nil, invoice.paid_on
+  end
+  
+  def test_whacko_payment_deletes
+    running_time = sanitize_time(Time.now - 1.years)
+    
+    payments = []
+    invoices = []
+    
+    [2,4,8,16,32,64,128,256,512,1024].each do |amt|
+      invoice = Factory.generate_invoice( amt, :issued_on => (running_time += 2.weeks) )
+      payments << Factory.generate_payment( amt, :paid_on => (running_time += 2.weeks) )
+      
+      assert_equal running_time, invoice.paid_on
+      invoices << invoice
+    end
+    
+    assert_equal 0.to_money, Factory.create_client.balance
+    
+    [9,7,5,3,1].each { |i| payments.delete_at(i).destroy }
+    
+    assert_equal 1364.to_money, Factory.create_client.balance
+
+    [1,3,5,7,9].each do |i|
+      running_time += 2.weeks
+      payments << Factory.generate_payment( invoices[i].amount, :paid_on => running_time )
+
+      assert_equal true, invoices[i].is_paid?
+      assert_equal running_time, invoices[i].paid_on
+    end
+    
+    assert_equal 0.to_money, Factory.create_client.balance
+
+    5.times { payments.delete_at(0).destroy }
+    
+    assert_equal 682.to_money, Factory.create_client.balance
+    
+    Factory.generate_payment 682, :paid_on => (running_time += 2.weeks) 
+    
+    [0,2,4,6,8].each { |i| assert_equal running_time, invoices[i].paid_on }
+    
+    assert_equal 0.to_money, Factory.create_client.balance
+  end
+
+  private
+  
+  def sanitize_time(time)
+    # This removes the usec's 
+    Time.utc time.sec, time.min, time.hour, time.day, time.month, time.year, time.wday, time.yday, time.isdst, time.gmt_offset unless time.nil?
+  end
+
+end

data/test/unit/setting_test.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class SettingTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/test/unit/slimtimer_task_test.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class SlimtimerTaskTest < ActiveSupport::TestCase
+  fixtures :slimtimer_tasks
+
+  # Replace this with your real tests.
+  def test_truth
+    assert true
+  end
+end

data/test/unit/slimtimer_time_entry_test.rb

@@ -0,0 +1,132 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class SlimtimerTimeEntryTest < ActiveSupport::TestCase
+  fixtures :employees, :employee_slimtimers, :credentials
+
+  def test_basics
+    chris = Employee.find 1
+    assert_not_nil chris
+      
+    ste = nil
+    
+    # Create
+    assert_nothing_raised do
+
+      start_time = Time.local 1982, 1, 4, 1, 0, 0 ,0
+      end_time   = start_time+3600 # plus 1h
+      
+      acme_lawncare = SlimtimerTask.create :name => 'Acme Lawn Care', :owner_employee_slimtimer_id => chris.slimtimer.id
+      assert_not_nil acme_lawncare
+      
+      ste = SlimtimerTimeEntry.create(
+        :employee_slimtimer_id => chris.slimtimer.id,
+        :comments => 'Trimmed Palm Trees',
+        :tags => 'billable',
+        :slimtimer_task => acme_lawncare,
+        :start_time => start_time,
+        :end_time => end_time
+      )
+    end
+    
+    assert_not_nil ste
+    assert_not_nil ste.labor
+    assert_not_nil ste.labor.activity
+
+    assert_not_nil ste.id
+    assert_not_nil ste.labor.id
+    assert_not_nil ste.labor.activity.id
+    
+    assert_equal 'Trimmed Palm Trees', ste.labor.comments
+    assert_equal 1, ste.labor.employee_id
+    assert_equal 60, ste.labor.minute_duration
+    assert_equal Time.local(1982, 1, 4, 1, 0, 0 ,0), ste.labor.activity.occurred_on
+    assert_equal 'Acme Lawn Care', ste.slimtimer_task.name
+    
+    # Test Update
+
+    # We create this here, and reuse it a couple times below b/c thats very convenient, and makes sure nothing has changed:
+    assert_acmebio_ste = Proc.new() do |on_ste|
+      assert_equal 'Engineered shorter Palm Trees', on_ste.labor.comments
+      assert_equal 1, on_ste.labor.employee_id
+      assert_equal 30, on_ste.labor.minute_duration
+      assert_equal Time.local(1985, 2, 4, 5, 0, 0 ,0), on_ste.labor.activity.occurred_on
+      assert_equal 'Acme Bio', on_ste.slimtimer_task.name
+    end
+    
+    assert_nothing_raised do
+      start_time = Time.local 1985, 2, 4, 5, 0, 0 ,0
+      end_time   = start_time+1800 # plus 30m
+      
+      acme_bio = SlimtimerTask.create :name => 'Acme Bio', :owner_employee_slimtimer_id => chris.slimtimer.id
+      assert_not_nil acme_bio
+      
+      ste.comments = 'Engineered shorter Palm Trees'
+      ste.slimtimer_task = acme_bio
+      ste.start_time = start_time
+      ste.end_time = end_time
+      
+      ste.save!
+    end
+    assert_acmebio_ste.call ste
+    
+    # Test Re-create on activity Delete
+    # NOTE: I decided this shouldnt be happening to begin with, and thus we shouldnt be too smart about fixing it if it happens..
+    
+    # Test Re-create on labor Delete
+    assert_nothing_raised do 
+      ste.labor.destroy 
+      ste.labor = nil
+      
+      ste.save!
+    end
+    assert_acmebio_ste.call ste
+    
+    # Set is_published and test destroy exceptions on delete, and on update
+    ste.labor.activity.is_published = true
+    
+    ste.labor.comments = "These should cause a raise"
+    assert_raise(StandardError) { ste.save! }
+
+    assert_raise(StandardError) { ste.destroy }
+  end
+  
+  def test_on_destroy 
+
+    ste_id = nil
+    ste_labor_id = nil
+    ste_activity_id = nil
+    
+    assert_nothing_raised do
+      chris = Employee.find 1
+      assert_not_nil chris
+    
+      start_time = Time.local 1999, 12, 31, 11, 59, 0 ,0
+      
+      acme_hairstyles = SlimtimerTask.create :name => 'Acme Hair Styles', :owner_employee_slimtimer_id => chris.slimtimer.id
+      assert_not_nil acme_hairstyles
+      
+      ste = SlimtimerTimeEntry.create(
+        :employee_slimtimer_id => chris.slimtimer.id,
+        :comments => 'Cornrolled Head',
+        :tags => 'billable',
+        :slimtimer_task => acme_hairstyles,
+        :start_time => start_time,
+        :end_time => start_time+60 # plus 1m
+      )
+      
+      ste_id = ste.id
+      ste_labor_id = ste.labor.id
+      ste_activity_id = ste.labor.activity.id
+      
+      ste.destroy
+    end
+    
+    assert_kind_of Integer, ste_id
+    assert_kind_of Integer, ste_labor_id
+    assert_kind_of Integer, ste_activity_id
+    
+    assert_raise(ActiveRecord::RecordNotFound) { SlimtimerTimeEntry.find ste_id }
+    assert_raise(ActiveRecord::RecordNotFound) { Activity::Labor.find ste_labor_id }
+    assert_raise(ActiveRecord::RecordNotFound) { Activity.find ste_activity_id }
+  end
+end

data/vendor/plugins/InlineAttachment-0.3.0-modified/README

@@ -0,0 +1,79 @@
+= Inline Attachment
+
+This package adds full support for embedding inline images into your HTML emails
+through ActionMailer.
+
+It is created from a Rails patch #2179 (found at http://dev.rubyonrails.org/ticket/2179).
+
+The goal of this gem is to remove the need for manual patching.
+
+== Installation
+
+To perform a system wide installation:
+
+<tt>gem install inline_attachment</tt>
+
+To use inline_attachment in your project, add the following line to your project's
+config/environment.rb:
+
+<tt>require 'inline_attachment'</tt>
+
+
+== Usage
+
+==== Embed Images Manually
+
+The code to add inline attachments into your HTML emails is pretty simple:
+
+	@cid = Time.now.to_f.to_s + "foobar.png@domain.com"
+ 
+	inline_attachment :content_type => "image/png", 
+	                  :body => File.read("#{RAILS_ROOT}/public/images/foobar.png"),
+	                  :filename => "foobar.png",
+	                  :cid => "<#{@cid}>"
+	
+Note that the above code should go into your ActionMailer.
+
+The instance variable @cid is the unique identifier your MIME email will be using to
+locate the attached image. All you have to do is then pass it over to your email
+template, and display it like so:
+
+	<img src="cid:<%= @cid %>" alt="Foo Bar" />
+	
+==== Embed Images Automatically
+
+As of version 0.2.0, Inline Attachment automatically embeds any images found within
+your ActionMailer templates. There is no longer any extra code required when adding images
+into your mail templates. Though, you must use rails image_tag helper when displaying
+images within your mailer views.
+
+With version 0.3.0, you are now able to embed images into nested parts by specifying 
+a part container to place the attached images into. For example:
+
+	class Notifier < ActionMailer::Base
+	  def images
+	    recipients   "test@test.com"
+	    from         "test@test.com"
+	    subject      "Test"
+	    content_type "multipart/alternative"
+    
+	    part "text/plain" do |p|
+	      p.body = render_message("images.text.plain.rhtml", {})
+	      p.content_disposition = ""
+	      p.transfer_encoding = "7bit"
+	      p.charset = "ISO-8859-15"
+	    end
+    
+	    part "multipart/related" do |p|
+	      p.parts << ActionMailer::Part.new(
+	        :content_type => "text/html", :body => render_message("images.text.html.rhtml", :part_container => p),
+	        :disposition => "",
+	        :charset => "ISO-8859-15",
+	        :transfer_encoding => "7bit"
+	      )
+	    end
+	  end
+	end
+	
+You can see that we passed in the variable :part_container => p into the body of the nested part.
+This needs to be done so that the images are embedded into the part that they are used in.

data/vendor/plugins/InlineAttachment-0.3.0-modified/init.rb

@@ -0,0 +1,2 @@
+require 'inline_attachment'
+require 'tmail_content_id'

data/vendor/plugins/InlineAttachment-0.3.0-modified/lib/inline_attachment.rb

@@ -0,0 +1,136 @@
+module ActionMailer
+  module PartContainer
+    # Add an inline attachment to a multipart message. 
+    def inline_attachment(params, &block)
+      params = { :content_type => params } if String === params
+      params = { :disposition => "inline",
+                 :transfer_encoding => "base64" }.merge(params)
+      params[:headers] ||= {}
+      params[:headers]['Content-ID'] = params[:cid]
+      part(params, &block)
+    end
+  end
+
+  class Part
+    def to_mail(defaults)
+      part = TMail::Mail.new
+
+      if @parts.empty?
+        part.content_transfer_encoding = transfer_encoding || "quoted-printable"
+        case (transfer_encoding || "").downcase
+          when "base64" then
+            part.body = TMail::Base64.folding_encode(body)
+          when "quoted-printable"
+            part.body = [Utils.normalize_new_lines(body)].pack("M*")
+          else
+            part.body = body
+        end
+
+        # Always set the content_type after setting the body and or parts
+
+        # CHANGE: treat attachments and inline files the same
+        if content_disposition == "attachment" || ((content_disposition == "inline") && filename)
+            part.set_content_type(content_type || defaults.content_type, nil,
+            squish("charset" => nil, "name" => filename))
+        else
+          part.set_content_type(content_type || defaults.content_type, nil,
+            "charset" => (charset || defaults.charset))    
+        end  
+                     
+        part.set_content_disposition(content_disposition, squish("filename" => filename)) unless content_disposition.blank?
+        headers.each {|k,v| part[k] = v }
+        # END CHANGE
+
+      else
+        if String === body
+          part = TMail::Mail.new
+          part.body = body
+          part.set_content_type content_type, nil, { "charset" => charset }
+          part.set_content_disposition "inline"
+          m.parts << part
+        end
+          
+        @parts.each do |p|
+          prt = (TMail::Mail === p ? p : p.to_mail(defaults))
+          part.parts << prt
+        end
+        
+        part.set_content_type(content_type, nil, { "charset" => charset }) if content_type =~ /multipart/
+      end
+    
+      part
+    end
+  end
+end
+
+module ActionView
+  module Helpers #:nodoc:
+    module AssetTagHelper
+      
+      # Brisk-Bills Adjustment
+      # This is a weird hack that fixes issues in produiction mode with inlineattachment - seems to work, so whatever?
+      alias image_path_without_inline_attachment image_path
+      def image_path(source)
+        @part_container ||= @controller
+        if @part_container.is_a?(ActionMailer::Base) or @part_container.is_a?(ActionMailer::Part)
+          '/images/%s' % source
+        else
+          image_path_without_inline_attachment(source)
+        end
+      end
+      # /Brisk-Bills
+      
+      def image_tag(source, options = {})
+        options.symbolize_keys!
+        
+        @part_container ||= @controller
+           
+        if @part_container.is_a?(ActionMailer::Base) or @part_container.is_a?(ActionMailer::Part)
+          file_path, basename, ext =/^.+?([^\/]+)\.([^\.]+)$/.match("#{RAILS_ROOT}/public#{image_path(source).split('?').first}").to_a
+
+          cid = Time.now.to_f.to_s + "#{basename}@inline_attachment"
+          
+          @part_container.inline_attachment(:content_type => "image/#{ext}",
+                                        :body         => File.open(file_path, 'rb').read,
+                                        :cid          => "<#{cid}>",
+                                        :disposition  => "inline")
+          
+          options[:src] = "cid:#{cid}"
+          options[:alt] ||= basename.capitalize
+        else
+          options[:src] = image_path(source)
+          options[:alt] ||= File.basename(options[:src], '.*').split('.').first.capitalize
+        end
+        
+        if options[:size]
+          options[:width], options[:height] = options[:size].split("x") if options[:size] =~ %r{^\d+x\d+$}
+          options.delete(:size)
+        end
+
+        tag("img", options)
+      end
+    end
+  end
+end
+
+class DummyClass
+  def relative_url_root
+    ""
+  end
+  
+  def protocol
+  "http"
+  end
+
+  def relative_url_root
+  ""
+  end
+end
+
+module ActionMailer #:nodoc:
+  class Base
+    def request
+      DummyClass.new
+    end
+  end
+end