erp_invoicing 4.0.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7e365f81c6acd92a870c00bb151777b8933d7958
-  data.tar.gz: 88c2affeaafa500990ecf8860884795884ee8e5c
+  metadata.gz: a500054d5b3b67fbb83faf39fd66c8fd9a397206
+  data.tar.gz: d40fe04522ecad5ee7a39d5d7b446e09a43570e8
 SHA512:
-  metadata.gz: d2fcce87ce55c3727b525fc20ebbdff65b0457d6b6f38912f5fa70203862c832ce372b0373342915d22e0349875716bf715fdda56ec36e0fb5e8a5d2aa0fa160
-  data.tar.gz: a8e691f4e4c3a213b89da8048fdc68dd97ba9043670fe917dc5c27e751c9af69d79d98bae6be5714645b403bc31e1bb8efefc349ecde2562838da47fda18b3ad
+  metadata.gz: 7fab6ace54f591e9655f1885e1bf3ea7d02490a40dfddf6d38dae03c7fd45e7658af79c30759ca389ec05343c54c4f8ba00251bd3bfa31789eb5bc6dd4676041
+  data.tar.gz: 8f2e5b22081f3aa2eaf343317f14e9bb4c518b3787d9acc3c4a0f693fbe407dbcc2cfc950ea799b63f1dc5cc3faff1eb5da87b66cb5b6574548474c5528b885c

data/app/controllers/api/v1/invoices_controller.rb

@@ -0,0 +1,26 @@
+module Api
+  module V1
+    class InvoicesController < BaseController
+
+      def index
+        query_filter = params[:query_filter].blank? ? {} : JSON.parse(params[:query_filter]).symbolize_keys
+
+        invoices = Invoice.apply_filters(query_filter)
+
+        # scope by dba organization
+        invoices = invoices.joins("inner join invoice_party_roles as invoice_party_reln on
+                          (invoice_party_reln.invoice_id = invoices.id
+                          and
+                          invoice_party_reln.party_id in (#{current_user.party.dba_organization.id})
+                          and
+                          invoice_party_reln.role_type_id = #{RoleType.iid('dba_org').id}
+                          )")
+
+        total_count = invoices.count
+
+        render json: {total_count: total_count, invoices: invoices.collect{|invoice| invoice.to_data_hash} }
+      end
+
+    end # InvoicesController
+  end # V1
+end # Api

data/app/models/billing_account.rb

@@ -2,6 +2,7 @@ class BillingAccount < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
   acts_as_financial_txn_account
+  has_payment_applications
 
   belongs_to :calculate_balance_strategy_type
   has_many :invoices, :dependent => :destroy do
@@ -13,14 +14,7 @@ class BillingAccount < ActiveRecord::Base
       all.sum(&:balance)
     end
   end
-  has_many :payment_applications, :as => :payment_applied_to, :dependent => :destroy do
-    def successful
-      all.select{|item| item.financial_txn.has_captured_payment?}
-    end
-    def pending
-      all.select{|item| item.is_pending?}
-    end
-  end
+
   has_one  :recurring_payment, :dependent => :destroy
 
   def self.find_by_account_number(account_number)
@@ -32,11 +26,6 @@ class BillingAccount < ActiveRecord::Base
     !self.recurring_payment.nil? and self.recurring_payment.enabled
   end
 
-  def has_payments?(status)
-    selected_payment_applications = self.get_payment_applications(status)
-    !(selected_payment_applications.nil? or selected_payment_applications.empty?)
-  end
-
   def all_documents
     (self.invoices.collect(&:document) | self.documents).flatten
   end
@@ -83,14 +72,6 @@ class BillingAccount < ActiveRecord::Base
      outstanding_balance_amt == 0 ? 0 : outstanding_balance_amt.round(2)
   end
 
-  def total_pending_payments
-    self.payment_applications.pending.sum{|item| item.money.amount}
-  end
-
-  def total_payments
-    self.payment_applications.successful.sum{|item| item.money.amount}
-  end
-
   #payment due is determined by last invoice
   def payment_due
     if !self.calculate_balance_strategy_type.nil? and self.calculate_balance_strategy_type.iid == 'invoices_and_payments' and !self.invoices.empty?

data/app/models/extensions/biz_txn_acct_root.rb

@@ -0,0 +1,5 @@
+BizTxnAcctRoot.class_eval do
+
+  has_many :invoice_items
+
+end

data/app/models/extensions/charge_line.rb

@@ -0,0 +1,5 @@
+ChargeLine.class_eval do
+
+  has_payment_applications
+
+end

data/app/models/extensions/order_txn.rb

@@ -0,0 +1,15 @@
+OrderTxn.class_eval do
+
+  def has_generated_invoice?
+    (Invoice.items_generated_by(self).count != 0)
+  end
+
+  def generated_invoice
+    Invoice.items_generated_by(self).first
+  end
+
+  def has_payments?(status=:all)
+    (has_generated_invoice? && Invoice.items_generated_by(self).first.has_payments?(status))
+  end
+
+end

data/app/models/invoice.rb

@@ -22,81 +22,284 @@ class Invoice < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
   acts_as_document
-  
-  belongs_to  :billing_account
-  belongs_to	:invoice_type
-  belongs_to  :invoice_payment_strategy_type
-  belongs_to  :balance_record, :class_name => "Money", :foreign_key => 'balance_id', :dependent => :destroy
-  belongs_to  :calculate_balance_strategy_type
-  has_many    :invoice_payment_term_sets, :dependent => :destroy
-  has_many    :payment_applications, :as => :payment_applied_to, :dependent => :destroy do
+  can_be_generated
+  has_tracked_status
+  tracks_created_by_updated_by
+
+  belongs_to :billing_account
+  belongs_to :invoice_type
+  belongs_to :invoice_payment_strategy_type
+  belongs_to :balance_record, :class_name => "Money", :foreign_key => 'balance_id', :dependent => :destroy
+  belongs_to :calculate_balance_strategy_type
+  has_many :invoice_payment_term_sets, :dependent => :destroy
+  has_many :payment_applications, :as => :payment_applied_to, :dependent => :destroy do
     def successful
-      all.select{|item| item.financial_txn.has_captured_payment?}
+      all.select { |item| item.financial_txn.has_captured_payment? }
     end
+
     def pending
-      all.select{|item| item.is_pending?}
+      all.select { |item| item.is_pending? }
     end
   end
-  has_many 	  :invoice_items, :dependent => :destroy do
+  has_many :invoice_items, :dependent => :destroy do
     def by_date
       order('created_at')
     end
 
     def unpaid
-      select{|item| item.balance > 0 }
+      select { |item| item.balance > 0 }
     end
   end
-  has_many 	  :invoice_party_roles, :dependent => :destroy
-	has_many	  :parties, :through => :invoice_party_roles
-  
+  has_many :invoice_party_roles, :dependent => :destroy
+  has_many :parties, :through => :invoice_party_roles
+
   alias :items :invoice_items
   alias :type :invoice_type
   alias :party_roles :invoice_party_roles
   alias :payment_strategy :invoice_payment_strategy_type
 
-  def has_payments?(status)
+  class << self
+
+    # Filter records
+    #
+    # @param filters [Hash] a hash of filters to be applied,
+    # @param statement [ActiveRecord::Relation] the query being built
+    # @return [ActiveRecord::Relation] the query being built
+    def apply_filters(filters, statement=nil)
+      if statement.nil?
+        statement = self
+      end
+
+      unless filters[:status].blank?
+        if filters[:status] == 'open'
+          statement = statement.open
+        end
+
+        if filters[:status] == 'closed'
+          statement = statement.closed
+        end
+      end
+
+      statement
+    end
+
+    # generate an invoice from a order_txn
+    # options include
+    # message - Message to display on Invoice
+    # invoice_date - Date of Invoice
+    # due_date - Due date of Invoice
+    # taxation - context for taxation
+    #   {
+    #     is_online_sale: true,
+    #         origin_address: {
+    #         state: "FL"
+    #     },
+    #         destination_address: {
+    #         state: "FL"
+    #     }
+    #   }
+    #
+    def generate_from_order(order_txn, options={})
+      ActiveRecord::Base.connection.transaction do
+        invoice = Invoice.new
+
+        # create invoice
+        invoice.invoice_number = next_invoice_number
+        invoice.description = "Invoice for #{order_txn.order_number.to_s}"
+        invoice.message = options[:message]
+        invoice.invoice_date = options[:invoice_date]
+        invoice.due_date = options[:due_date]
+
+        invoice.save
+
+        invoice.current_status = 'invoice_statuses_open'
+
+        # add customer relationship
+        party = order_txn.find_party_by_role('order_roles_customer')
+        invoice.add_party_with_role_type(party, RoleType.customer)
+
+        dba_organization = options[:dba_organization] || order_txn.find_party_by_role(RoleType.iid('dba_org'))
+        invoice.add_party_with_role_type(dba_organization, RoleType.dba_org)
+
+        order_txn.order_line_items.each do |line_item|
+          invoice_item = InvoiceItem.new
+
+          invoice_item.invoice = invoice
+
+          charged_item = line_item.product_instance || line_item.product_offer ||line_item.product_type
+
+          invoice_item.item_description = charged_item.description
+          invoice_item.quantity = line_item.quantity
+          invoice_item.unit_price = line_item.sold_price
+          invoice_item.amount = (line_item.quantity * line_item.sold_price)
+          invoice_item.taxed = line_item.taxed?
+          invoice_item.biz_txn_acct_root = charged_item.try(:biz_txn_acct_root)
+          invoice_item.add_invoiced_record(charged_item)
+
+          invoice.invoice_items << invoice_item
+
+          invoice_item.save
+        end
+
+        # handles everything but shipping charge lines, multiple invoice items created from all iterations
+        order_txn.all_charge_lines.select { |charge_line| charge_line.charge_type && charge_line.charge_type.internal_identifier != 'shipping' }.each do |charge_line|
+          invoice_item = InvoiceItem.new
+
+          invoice_item.invoice = invoice
+          charged_item = charge_line.charged_item
+          invoice_item.item_description = charge_line.description
+
+          # set data based on charged item either a OrderTxn or OrderLineItem
+          if charged_item.is_a?(OrderLineItem)
+            invoice_item.quantity = charged_item.quantity
+            invoice_item.unit_price = charged_item.sold_price
+            invoice_item.amount = charged_item.sold_amount
+            invoice_item.add_invoiced_record(charged_item.line_item_record)
+            invoice_item.taxed = charged_item.taxed?
+          elsif charged_item.is_a?(OrderTxn)
+            invoice_item.quantity = 1
+            invoice_item.unit_price = charge_line.money.amount
+            invoice_item.amount = charge_line.money.amount
+            invoice_item.add_invoiced_record(charge_line)
+          end
+
+          invoice.invoice_items << invoice_item
+
+          invoice_item.save!
+        end
+
+        # handles shipping charge lines, one invoice item created from all iterations
+        shipping_charges = order_txn.all_charge_lines.select { |charge_line| charge_line.charge_type && charge_line.charge_type.internal_identifier == 'shipping' }
+        if shipping_charges.length > 0
+          shipping_invoice_item = InvoiceItem.new
+          shipping_charges.each do |charge_line|
+            shipping_invoice_item.item_description = charge_line.description
+            shipping_invoice_item.invoice = invoice
+            shipping_invoice_item.quantity = 1
+            shipping_invoice_item.amount = shipping_invoice_item.unit_price.nil? ? charge_line.money.amount : shipping_invoice_item.unit_price + charge_line.money.amount
+            shipping_invoice_item.unit_price = shipping_invoice_item.unit_price.nil? ? charge_line.money.amount : shipping_invoice_item.unit_price + charge_line.money.amount
+            shipping_invoice_item.taxed = charge_line.taxed?
+            shipping_invoice_item.add_invoiced_record(charge_line)
+
+            invoice.invoice_items << shipping_invoice_item
+          end
+          shipping_invoice_item.save
+        end
+
+        invoice.generated_by = order_txn
+
+        # calculate taxes
+        invoice.calculate_tax(options[:taxation])
+
+        invoice
+      end
+    end
+
+    def next_invoice_number
+      max_id = maximum('id')
+
+      current_invoice = where(Invoice.arel_table[:invoice_number].matches("%#{max_id}%")).first
+
+      if current_invoice
+        while current_invoice
+          max_id = max_id + 1
+          current_invoice = where(Invoice.arel_table[:invoice_number].matches("%#{max_id}%")).first
+        end
+      else
+        if max_id
+          max_id = max_id + 1
+        else
+          max_id = 1
+        end
+      end
+
+      "Inv-#{max_id}"
+    end
+
+    def open
+      Invoice.with_current_status(['invoice_statuses_open'])
+    end
+
+    def closed
+      Invoice.with_current_status(['invoice_statuses_closed'])
+    end
+
+    def hold
+      Invoice.with_current_status(['invoice_statuses_hold'])
+    end
+
+    def sent
+      Invoice.with_current_status(['invoice_statuses_sent'])
+    end
+  end
+
+  def has_invoice_items?
+    !self.items.empty?
+  end
+
+  def has_payments?(status=:all)
     selected_payment_applications = self.get_payment_applications(status)
+
     !(selected_payment_applications.nil? or selected_payment_applications.empty?)
   end
 
   def get_payment_applications(status=:all)
     selected_payment_applications = case status.to_sym
-    when :pending
-      self.payment_applications.pending
-    when :successful
-      self.payment_applications.successful
-    when :all
-      self.payment_applications
-    end
+                                      when :pending
+                                        self.payment_applications.pending
+                                      when :successful
+                                        self.payment_applications.successful
+                                      when :all
+                                        self.payment_applications
+                                    end
 
     unless self.items.empty?
-      selected_payment_applications = (selected_payment_applications | self.items.collect{|item| item.get_payment_applications(status)}).flatten! unless (self.items.collect{|item| item.get_payment_applications(status)}.empty?)
+      unless self.items.collect { |item| item.get_payment_applications(status) }.empty?
+        selected_payment_applications = (selected_payment_applications | self.items.collect { |item| item.get_payment_applications(status) }).flatten!
+      end
     end
-    
+
     selected_payment_applications
   end
 
-  def calculate_balance
-    unless self.calculate_balance_strategy_type.nil?
-      case self.calculate_balance_strategy_type.internal_identifier
-        when 'invoice_items_and_payments'
-          (self.items.all.sum(&:total_amount) - self.total_payments)
-        when 'payable_balances_and_payments'
-           (self.payable_balances.all.sum(&:balance).amount - self.total_payments)
-        when 'payments'
-          (self.balance - self.total_payments)
-        else
-          self.balance
+  def sub_total
+    if items.empty?
+      if self.balance_record
+        self.balance_record.amount
+      else
+        0
+      end
+    else
+      self.items.all.sum(&:sub_total).round(2)
+    end
+  end
+
+  def total_amount
+    if items.empty?
+      if self.balance_record
+        self.balance_record.amount
+      else
+        0
       end
     else
-      self.balance
+      self.items.all.sum(&:total_amount).round(2)
     end
   end
 
   def balance
-    self.balance_record.amount
+    if items.empty?
+      if self.balance_record
+        self.balance_record.amount
+      else
+        0
+      end
+    else
+      self.items.all.sum(&:total_amount).round(2)
+    end
   end
 
+  alias payment_due balance
+
   def balance=(amount, currency=Currency.usd)
     if self.balance_record
       self.balance_record.amount = amount
@@ -106,12 +309,45 @@ class Invoice < ActiveRecord::Base
     self.balance_record.save
   end
 
-  def payment_due
-    self.items.all.sum(&:total_amount)
+  def total_payments
+    self.get_payment_applications(:successful).sum { |item| item.money.amount }
   end
 
-  def total_payments
-    self.get_payment_applications(:successful).sum{|item| item.money.amount}
+  # calculates tax for each line item and save to sales_tax
+  def calculate_tax(ctx={})
+    tax = 0
+
+    self.invoice_items.each do |line_item|
+      tax += line_item.calculate_tax(ctx)
+    end
+
+    self.sales_tax = tax
+    self.save
+
+    tax
+  end
+
+  def calculate_balance
+    unless self.calculate_balance_strategy_type.nil?
+      case self.calculate_balance_strategy_type.internal_identifier
+        when 'invoice_items_and_payments'
+          (self.items.all.sum(&:total_amount) - self.total_payments).round(2)
+        when 'payable_balances_and_payments'
+          (self.payable_balances.all.sum(&:balance).amount - self.total_payments).round(2)
+        when 'payments'
+          (self.balance - self.total_payments).round(2)
+        else
+          self.balance
+      end
+    else
+      unless self.balance.nil?
+        if has_invoice_items?
+          (self.balance - self.total_payments).round(2)
+        else
+          self.balance.round(2)
+        end
+      end
+    end
   end
 
   def transactions
@@ -119,23 +355,23 @@ class Invoice < ActiveRecord::Base
 
     self.items.each do |item|
       transactions << {
-        :date => item.created_at,
-        :description => item.item_description,
-        :quantity => item.quantity,
-        :amount => item.amount
+          :date => item.created_at,
+          :description => item.item_description,
+          :quantity => item.quantity,
+          :amount => item.amount
       }
     end
 
     self.get_payment_applications(:successful).each do |item|
       transactions << {
-        :date => item.financial_txn.payments.last.created_at,
-        :description => item.financial_txn.description,
-        :quantity => 1,
-        :amount => (0 - item.financial_txn.money.amount)
+          :date => item.financial_txn.payments.last.created_at,
+          :description => item.financial_txn.description,
+          :quantity => 1,
+          :amount => (0 - item.financial_txn.money.amount)
       }
     end
 
-    transactions.sort_by{|item| [item[:date]]}
+    transactions.sort_by { |item| [item[:date]] }
   end
 
   def add_party_with_role_type(party, role_type)
@@ -147,6 +383,22 @@ class Invoice < ActiveRecord::Base
     self.invoice_party_roles.where('role_type_id = ?', convert_role_type(role_type).id).all.collect(&:party)
   end
 
+  def find_party_by_role_type(role_type)
+    parties = find_parties_by_role_type(role_type)
+
+    unless parties.empty?
+      parties.first
+    end
+  end
+
+  def dba_organization
+    find_parties_by_role_type('dba_org').first
+  end
+
+  def to_data_hash
+    to_hash(only: [:id, :created_at, :updated_at, :description, :invoice_number, :invoice_date, :due_date])
+  end
+
   private
 
   def convert_role_type(role_type)
@@ -155,5 +407,5 @@ class Invoice < ActiveRecord::Base
 
     role_type
   end
-	
+
 end

data/app/models/invoice_item.rb

@@ -1,47 +1,106 @@
+#### Table Definition ###########################
+#  create_table :invoice_items do |t|
+#    #foreign keys
+#    t.references :invoice
+#    t.references :invoice_item_type
+#
+#    #non-key columns
+#    t.integer    :item_seq_id
+#    t.string     :item_description
+#    t.decimal    :unit_price, :precision => 8, :scale => 2
+#    t.boolean    :taxed
+#    t.decimal    :sales_tax, :precision => 8, :scale => 2
+#    t.decimal    :quantity, :precision => 8, :scale => 2
+#    t.decimal    :amount, :precision => 8, :scale => 2
+#
+#    t.timestamps
+#  end
+
+#  add_index :invoice_items, :invoice_id, :name => 'invoice_id_idx'
+#  add_index :invoice_items, :invoice_item_type_id, :name => 'invoice_item_type_id_idx'
+#################################################
+
 class InvoiceItem < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
-	belongs_to 	:agreement
-	belongs_to	:agreement_item_type
-  belongs_to  :invoiceable_item, :polymorphic => true
+  has_payment_applications
+  tracks_created_by_updated_by
+
+  belongs_to :invoice
+  belongs_to :agreement
+  belongs_to :invoice_item_type
+  belongs_to :biz_txn_acct_root
+
+  has_many :invoiced_records, :dependent => :destroy
+  has_many :sales_tax_lines, as: :taxed_record, dependent: :destroy
+
+  alias :gl_account :biz_txn_acct_root
+
+  def taxed?
+    self.taxed
+  end
 
-	#This line of code connects the invoice to a polymorphic payment application.
-	#The effect of this is to allow payments to be "applied_to" invoices
-  has_many    :payment_applications, :as => :payment_applied_to, :dependent => :destroy do
-    def pending
-      all.select{|item| item.is_pending?}
+  def total_amount
+    if taxed?
+      (sub_total + (self.sales_tax || 0)).round(2)
+    else
+      sub_total
     end
-    def successful
-      all.select{|item| item.financial_txn.has_captured_payment?}
+  end
+
+  def sub_total
+    _amount = self.amount
+
+    if _amount.blank?
+      _amount = (self.unit_price * self.quantity)
     end
+
+    _amount.round(2)
   end
 
-  def has_payments?(status)
-    selected_payment_applications = self.get_payment_applications(status)
-    !(selected_payment_applications.nil? or selected_payment_applications.empty?)
+  def balance
+    (self.total_amount - self.total_payments).round(2)
   end
-  
-  def get_payment_applications(status=:all)
-    case status.to_sym
-    when :pending
-      self.payment_applications.pending
-    when :successful
-      self.payment_applications.successful
-    when :all
-      self.payment_applications
+
+  # calculates tax and save to sales_tax
+  def calculate_tax(ctx={})
+    tax = 0
+
+    # see if anything is taxed
+    if invoiced_records.collect { |item| item.taxed? }.include?(true)
+      taxation = ErpOrders::Taxation.new
+
+      tax += taxation.calculate_tax(self,
+                                    ctx.merge({
+                                                  amount: (self.unit_price * (self.quantity || 1))
+                                              }))
     end
+
+    tax
   end
 
-  def total_amount
-    (self.amount * self.quantity)
+  def add_invoiced_record(record)
+    invoiced_records << InvoicedRecord.new(invoiceable_item: record)
   end
 
-   def total_payments
-    self.get_payment_applications(:successful).sum{|item| item.money.amount}
+  def to_s
+    item_description
   end
 
-  def balance
-    self.total_amount - self.total_payments
+  def product_descriptions
+    # return an array of product descriptions for this invoice item
+    descriptions = []
+    invoiced_records.each do |invoiced_record|
+      descriptions << invoiced_record.invoiceable_item.description
+    end
+    if descriptions.count == 0
+      descriptions << "No Product Description"
+    end
+    descriptions
+  end
+
+  def to_label
+    to_s
   end
 
 end

data/app/models/invoice_party_role.rb

@@ -6,10 +6,10 @@
 #    t.string :external_id_source
 #    t.references :invoice
 #    t.references :party
-
+#
 #    t.timestamps
 #  end
-
+#
 #  add_index :invoice_party_roles, :invoice_id, :name => 'invoice_party_invoice_id_idx'
 #  add_index :invoice_party_roles, :party_id, :name => 'invoice_party_party_id_idx'
 #################################################

data/app/models/invoiced_record.rb

@@ -0,0 +1,19 @@
+class InvoicedRecord < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
+  belongs_to :invoice_item
+  belongs_to :invoiceable_item, :polymorphic => true
+
+  # Weather or not this item is taxed
+  #
+  def taxed?
+    if invoiceable_item.respond_to?(:taxed?)
+      invoiceable_item.taxed?
+    elsif invoiceable_item.respond_to?(:taxable?)
+      invoiceable_item.taxable?
+    else
+      false
+    end
+  end
+
+end

data/app/models/payment_application.rb

@@ -18,6 +18,8 @@
 class PaymentApplication < ActiveRecord::Base
   attr_protected :created_at, :updated_at
 
+  tracks_created_by_updated_by
+
   belongs_to :financial_txn
   belongs_to :payment_applied_to, :polymorphic => true
   belongs_to :money, :foreign_key => 'applied_money_amount_id', :dependent => :destroy

data/config/routes.rb

@@ -1,13 +1,14 @@
-ErpInvoicing::Engine.routes.draw do
+Rails.application.routes.draw do
+
+  namespace :api do
+    namespace :v1 do
 
-  match '/sms/receive_response' => "sms#receive_response"
+      resources :invoices, :defaults => {:format => 'json'}
 
-  match '/erp_app/organizer/bill_pay/base(/:action)' => "erp_app/organizer/bill_pay/base#index"
-  match '/erp_app/organizer/bill_pay/accounts(/:action)' => "erp_app/organizer/bill_pay/accounts#index"
+    end # v1
+  end # api
 
-  #shared
-  match '/erp_app/shared/billing_accounts(/:action(/:id))' => "erp_app/shared/billing_accounts"
-  match '/erp_app/shared/invoices(/:action(/:id))' => "erp_app/shared/invoices"
-  match '/erp_app/shared/invoices/files/:invoice_id(/:action)' => "erp_app/shared/files"
-  
+end
+
+ErpInvoicing::Engine.routes.draw do
 end

data/db/data_migrations/20160117135959_add_invoice_tracked_statuses.rb

@@ -0,0 +1,19 @@
+class AddInvoiceTrackedStatuses
+
+  def self.up
+    invoice_statuses = TrackedStatusType.find_or_create('invoice_statuses', 'Invoice Statuses')
+
+    TrackedStatusType.find_or_create('invoice_statuses_open', 'Open', invoice_statuses)
+    TrackedStatusType.find_or_create('invoice_statuses_hold', 'Hold', invoice_statuses)
+    TrackedStatusType.find_or_create('invoice_statuses_sent', 'Sent', invoice_statuses)
+    TrackedStatusType.find_or_create('invoice_statuses_closed', 'Closed', invoice_statuses)
+  end
+
+  def self.down
+    status = TrackedStatusType.where(internal_identifier: 'invoice_statuses').first
+    if status
+      status.destroy
+    end
+  end
+
+end

data/db/migrate/20111121000000_invoicing_services.rb

@@ -70,25 +70,36 @@ class InvoicingServices < ActiveRecord::Migration
         #foreign keys      
         t.references :invoice
         t.references :invoice_item_type
-        
-        #these columns support the polymporphic relationship to invoice-able items
-        t.references :invoiceable_item, :polymorphic => true
 
         #non-key columns
         t.integer    :item_seq_id
         t.string     :item_description
-        t.decimal    :sales_tax, :precision => 8, :scale => 2
         t.decimal    :quantity, :precision => 8, :scale => 2
         t.decimal    :amount, :precision => 8, :scale => 2
+        t.boolean    :taxable
+        t.decimal    :tax_rate, :precision => 8, :scale => 2
+        t.decimal    :unit_price, :precision => 8, :scale => 2
         
         t.timestamps
       end
 
-      add_index :invoice_items, [:invoiceable_item_id, :invoiceable_item_type], :name => 'invoiceable_item_idx'
       add_index :invoice_items, :invoice_id, :name => 'invoice_id_idx'
       add_index :invoice_items, :invoice_item_type_id, :name => 'invoice_item_type_id_idx'
     end
-    
+
+
+    # Create invoiced records
+    unless table_exists?(:invoiced_records)
+      create_table :invoiced_records do |t|
+        t.references :invoice_item
+        t.references :invoiceable_item, :polymorphic => true
+
+        t.timestamps
+      end
+
+      add_index :invoiced_records, [:invoiceable_item_id, :invoiceable_item_type], :name => 'invoiced_records_invoiceable_item_idx'
+    end
+
     # Create invoice item types
     unless table_exists?(:invoice_item_types)
       create_table :invoice_item_types do |t|
@@ -265,7 +276,8 @@ class InvoicingServices < ActiveRecord::Migration
       :invoice_items, :invoice_item_types, :invoice_party_roles,
       :billing_accounts, :billing_contact_mechanisms,
       :payment_applications, :payment_party_roles, :recurring_payments,
-      :invoice_payment_term_sets,:invoice_payment_terms,:invoice_payment_term_types, :calculate_balance_strategy_types
+      :invoice_payment_term_sets,:invoice_payment_terms,:invoice_payment_term_types,
+      :calculate_balance_strategy_types, :invoiced_records
     ].each do |tbl|
       if table_exists?(tbl)
         drop_table tbl

data/db/migrate/20150424193506_change_invoice_item_description_to_text.rb

@@ -0,0 +1,9 @@
+class ChangeInvoiceItemDescriptionToText < ActiveRecord::Migration
+  def up
+    change_column :invoice_items, :item_description, :text
+  end
+
+  def down
+    change_column :invoice_items, :item_description, :string
+  end
+end

data/db/migrate/20150622170437_update_taxation_for_invoices.rb

@@ -0,0 +1,50 @@
+class UpdateTaxationForInvoices < ActiveRecord::Migration
+  def up
+
+    if column_exists? :invoice_items, :tax_rate
+      remove_column :invoice_items, :tax_rate
+    end
+
+    unless column_exists? :invoice_items, :sales_tax
+      add_column :invoice_items, :sales_tax, :decimal, precision: 8, scale: 2
+    end
+
+    unless column_exists? :invoice_items, :taxed
+      add_column :invoice_items, :taxed, :boolean
+    end
+
+    if column_exists? :invoice_items, :taxable
+      remove_column :invoice_items, :taxable
+    end
+
+    unless column_exists? :invoices, :sales_tax
+      add_column :invoices, :sales_tax, :decimal, precision: 8, scale: 2
+    end
+
+  end
+
+  def down
+
+    unless column_exists? :invoice_items, :tax_rate
+      add_column :invoice_items, :tax_rate, :decimal, precision: 8, scale: 2
+    end
+
+    if column_exists? :invoice_items, :sales_tax
+      remove_column :invoice_items, :sales_tax
+    end
+
+    if column_exists? :invoice_items, :taxed
+      remove_column :invoice_items, :taxed
+    end
+
+    unless column_exists? :invoice_items, :taxable
+      add_column :invoice_items, :taxable, :boolean
+    end
+
+    if column_exists? :invoices, :sales_tax
+      remove_column :invoices, :sales_tax
+    end
+
+  end
+
+end

data/db/migrate/20151217185838_add_biz_txn_acct_root_id_to_invoice_item.rb

@@ -0,0 +1,15 @@
+class AddBizTxnAcctRootIdToInvoiceItem < ActiveRecord::Migration
+  def up
+    unless column_exists? :invoice_items, :biz_txn_acct_root_id
+      add_column :invoice_items, :biz_txn_acct_root_id, :integer
+
+      add_index :invoice_items, :biz_txn_acct_root_id
+    end
+  end
+
+  def down
+    if column_exists? :invoice_items, :biz_txn_acct_root_id
+      remove_column :invoice_items, :biz_txn_acct_root_id
+    end
+  end
+end

data/db/migrate/20160310163059_add_created_by_updated_by_to_erp_invoicing.rb

@@ -0,0 +1,35 @@
+class AddCreatedByUpdatedByToErpInvoicing < ActiveRecord::Migration
+  def up
+    %w{invoices invoice_items payment_applications}.each do |table|
+
+      unless column_exists? table.to_sym, :created_by_party_id
+        add_column table.to_sym, :created_by_party_id, :integer
+
+        add_index table.to_sym, :created_by_party_id, name: "#{table}_created_by_pty_idx"
+      end
+
+      unless column_exists? table.to_sym, :updated_by_party_id
+        add_column table.to_sym, :updated_by_party_id, :integer
+
+        add_index table.to_sym, :updated_by_party_id, name: "#{table}_updated_by_pty_idx"
+      end
+
+    end
+
+  end
+
+  def down
+    %w{invoices invoice_items payment_applications}.each do |table|
+
+      if column_exists? table.to_sym, :created_by_party_id
+        remove_column table.to_sym, :created_by_party_id
+      end
+
+      if column_exists? table.to_sym, :updated_by_party_id
+        remove_column table.to_sym, :updated_by_party_id
+      end
+    end
+
+  end
+
+end

data/lib/erp_invoicing.rb

@@ -2,6 +2,7 @@ require 'erp_base_erp_svcs'
 require 'erp_app'
 require 'knitkit'
 
+require 'erp_invoicing/extensions/active_record/has_payment_applications'
 require "erp_invoicing/version"
 require "erp_invoicing/engine"
 

data/lib/erp_invoicing/engine.rb

@@ -2,8 +2,8 @@ module ErpInvoicing
   class Engine < Rails::Engine
     isolate_namespace ErpInvoicing
 
-    initializer "erp_invoicing.merge_public" do |app|
-      app.middleware.insert_before Rack::Runtime, ::ActionDispatch::Static, "#{root}/public"
+    ActiveSupport.on_load(:active_record) do
+      include ErpInvoicing::Extensions::ActiveRecord::HasPaymentApplications
     end
 
     ErpBaseErpSvcs.register_as_compass_ae_engine(config, self)

data/lib/erp_invoicing/extensions/active_record/has_payment_applications.rb

@@ -0,0 +1,62 @@
+module ErpInvoicing
+  module Extensions
+    module ActiveRecord
+      module HasPaymentApplications
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def has_payment_applications
+            extend HasPaymentApplications::SingletonMethods
+            include HasPaymentApplications::InstanceMethods
+
+            has_many :payment_applications, :as => :payment_applied_to, :dependent => :destroy do
+              def pending
+                all.select{|item| item.is_pending?}
+              end
+
+              def successful
+                all.select{|item| item.financial_txn.has_captured_payment?}
+              end
+            end
+
+          end
+
+        end
+
+        module SingletonMethods
+        end
+
+        module InstanceMethods
+
+          def get_payment_applications(status=:all)
+            case status.to_sym
+              when :pending
+                payment_applications.pending
+              when :successful
+                payment_applications.successful
+              when :all
+                payment_applications
+            end
+          end
+
+          def has_payments?(status=:all)
+            selected_payment_applications = self.get_payment_applications(status)
+            !(selected_payment_applications.nil? or selected_payment_applications.empty?)
+          end
+
+          def total_payments
+            self.get_payment_applications(:successful).sum { |item| item.money.amount }
+          end
+
+          def total_pending_payments
+            self.payment_applications.pending.sum{|item| item.money.amount}
+          end
+
+        end
+
+      end #End HasPaymentApplications module
+    end #End ActiveRecord module
+  end #End Extensions module
+end #End ErpInvoicing module

data/lib/erp_invoicing/version.rb

@@ -1,7 +1,7 @@
 module ErpInvoicing
   module VERSION #:nodoc:
     MAJOR = 4
-    MINOR = 0
+    MINOR = 1
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].compact.join('.')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: erp_invoicing
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.1.0
 platform: ruby
 authors:
 - Rick Koloski, Russell Holmes
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-19 00:00:00.000000000 Z
+date: 2016-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: erp_work_effort
@@ -16,56 +16,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4.1'
 - !ruby/object:Gem::Dependency
   name: erp_commerce
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4.1'
 - !ruby/object:Gem::Dependency
   name: knitkit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: erp_dev_svcs
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4.1'
 description: ErpInvoicing adds models and services to the CompassAE core to handle
   invoicing and billing functions. It includes extensions to the core ERP classes
   for accounts and things that are 'billable' (products, work efforts), and additional
@@ -81,11 +81,15 @@ files:
 - GPL-3-LICENSE
 - README.rdoc
 - Rakefile
+- app/controllers/api/v1/invoices_controller.rb
 - app/models/billing_account.rb
 - app/models/calculate_balance_strategy_type.rb
+- app/models/extensions/biz_txn_acct_root.rb
+- app/models/extensions/charge_line.rb
 - app/models/extensions/document.rb
 - app/models/extensions/financial_txn.rb
 - app/models/extensions/financial_txn_account.rb
+- app/models/extensions/order_txn.rb
 - app/models/extensions/party.rb
 - app/models/extensions/product_instance.rb
 - app/models/extensions/product_type.rb
@@ -99,13 +103,20 @@ files:
 - app/models/invoice_payment_term_set.rb
 - app/models/invoice_payment_term_type.rb
 - app/models/invoice_type.rb
+- app/models/invoiced_record.rb
 - app/models/payment_application.rb
 - app/models/recurring_payment.rb
 - config/routes.rb
 - db/data_migrations/20120605154637_add_calculate_balance_strategy_types.rb
+- db/data_migrations/20160117135959_add_invoice_tracked_statuses.rb
 - db/migrate/20111121000000_invoicing_services.rb
+- db/migrate/20150424193506_change_invoice_item_description_to_text.rb
+- db/migrate/20150622170437_update_taxation_for_invoices.rb
+- db/migrate/20151217185838_add_biz_txn_acct_root_id_to_invoice_item.rb
+- db/migrate/20160310163059_add_created_by_updated_by_to_erp_invoicing.rb
 - lib/erp_invoicing.rb
 - lib/erp_invoicing/engine.rb
+- lib/erp_invoicing/extensions/active_record/has_payment_applications.rb
 - lib/erp_invoicing/version.rb
 - lib/tasks/erp_invoicing_tasks.rake
 - spec/dummy/Rakefile
@@ -159,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: ErpInvoicing adds models and services to the CompassAE core to handle invoicing