erp_invoicing 3.0.0 → 3.0.1

data/app/controllers/erp_invoicing/sms_controller.rb

@@ -0,0 +1,156 @@
+module ErpInvoicing
+  class SmsController < ::ActionController::Base
+    before_filter :allow_by_ip
+
+    # Receive SMS callback from clickatell
+    # Example: If you provide this URL http://www.yourdomain.com/erp_invoicing/sms/receive_response then we will do a POST or GET as follows:
+    # https://www.yourdomain.com/sms/receive_response?api_id=12345&from=279991235642&to=27123456789&
+    # timestamp=2008-08-0609:43:50&text=Hereisthe%20messagetext&charset=ISO-8859-1&udh=&moMsgId=b2aee337abd962489b123fda9c3480fa
+    def receive_response
+      message_text = params[:text]
+      moMsgId = params[:moMsgId]
+      to_number = params[:to]
+      from_number = params[:from]
+
+      if message_text.blank? or to_number.blank? or from_number.blank?
+        Rails.logger.error 'ErpInvoicing::SmsController#receive_response called with insufficient data'
+        render_false and return
+        render :json => {:success => false} and return
+      end
+
+      # find the comm event sent within past 10mins where that incoming message is a reponse to
+      cmm_evt = CommunicationEvent.find_by_sql("SELECT * FROM communication_events
+                                    JOIN phone_numbers from_phone ON from_contact_mechanism_id=from_phone.id
+                                    JOIN phone_numbers to_phone ON to_contact_mechanism_id=to_phone.id
+                                    WHERE from_contact_mechanism_type = 'PhoneNumber' 
+                                    AND from_contact_mechanism_type='PhoneNumber'
+                                    AND from_phone.phone_number = '#{to_number.to_s}'
+                                    AND (to_phone.phone_number = '#{from_number.to_s}' OR to_phone.phone_number = '#{from_number[1..from_number.length]}')
+                                    AND communication_events.created_at > '#{SMS_TIME_WINDOW.minutes.ago.to_s}'
+                                    ORDER BY communication_events.created_at DESC").first
+
+      unless cmm_evt.nil?
+        if message_text.downcase.include?('yespay') or message_text.downcase.include?('yes pay')
+          billing_account = BillingAccount.find(cmm_evt.case_id)
+          payment_due = billing_account.payment_due
+
+          # TODO: scrape for amount and compare with payment_due on account?
+
+          if billing_account.has_outstanding_balance?
+            success = submit_payment(cmm_evt, billing_account) if billing_account.has_outstanding_balance?
+          else
+            Rails.logger.error 'ErpInvoicing::SmsController#receive_response called: skipping payment NO OUTSTANDING BALANCE TO PAY'
+          end
+          to_party = cmm_evt.from_party
+
+          # log communication event
+          new_cmm_evt = CommunicationEvent.new
+          new_cmm_evt.short_description = 'SMS Response'
+          new_cmm_evt.comm_evt_purpose_types << CommEvtPurposeType.find_by_internal_identifier('sms_response')
+          new_cmm_evt.to_role = RoleType.find_by_internal_identifier('application')
+          new_cmm_evt.to_party = to_party
+          new_cmm_evt.to_contact_mechanism = to_party.default_phone_number
+          new_cmm_evt.from_contact_mechanism = cmm_evt.to_party.billing_phone_number
+          new_cmm_evt.from_role = RoleType.find_by_internal_identifier('customer')
+          new_cmm_evt.from_party = cmm_evt.to_party
+          new_cmm_evt.case_id = cmm_evt.case_id
+          new_cmm_evt.notes = "From Number: #{from_number}, To Number: #{to_number}, Message: #{message_text}, Payment: #{success}"
+          new_cmm_evt.external_identifier = moMsgId
+          new_cmm_evt.save
+
+          if success
+            # send successful payment notification
+            clikatell = ErpTechSvcs::SmsWrapper::Clickatell.new
+            clikatell.send_message(from_number, SMS_SUCCESS_NOTIFICATION.gsub('payment_due', payment_due.to_s), :mo => 1, :from => to_number)
+            render_true and return
+          else
+            render_false and return
+          end
+        end
+      else
+        Rails.logger.error "ErpInvoicing::SmsController#receive_  ation event #{moMsgId}"
+        render :json => {:success => false} and return
+      end
+    end
+
+    protected
+    def submit_payment(cmm_evt, billing_account)
+      party = cmm_evt.to_party
+
+      @error_message = nil
+      @message = nil
+      @payment_accounts = party.payment_accounts
+
+      root_account = BizTxnAcctRoot.find(@payment_accounts.first)
+      @payment_account = root_account.account
+      @amount = billing_account.payment_due
+      @payment_date = Date.today
+      
+      money = Money.create(
+        :amount => @amount.to_f,
+        :description => "Clicktopay Payment Applied",
+        :currency => Currency.usd
+      )
+      financial_txn = FinancialTxn.new(:apply_date => @payment_date)
+      financial_txn.description = "Clicktopay Payment Applied"
+      financial_txn.money = money
+      financial_txn.account = root_account
+      financial_txn.save
+      
+      PaymentApplication.create(
+        :financial_txn => financial_txn,
+        :payment_applied_to => billing_account,
+        :money => money
+      )
+
+      if financial_txn.apply_date == Date.today
+        case @payment_account.class.to_s
+        when "BankAccount"
+          financial_txn.txn_type = BizTxnType.ach_sale
+          financial_txn.save
+          result = @payment_account.purchase(financial_txn, ErpCommerce::Config.active_merchant_gateway_wrapper)
+          if !result[:payment].nil? and result[:payment].success
+            @authorization_code = result[:payment].authorization_code
+          else
+            @message = result[:message]
+          end
+        when "CreditCardAccount"
+          financial_txn.txn_type = BizTxnType.cc_sale
+          financial_txn.save
+          result = @payment_account.purchase(financial_txn, '123', ErpCommerce::Config.active_merchant_gateway_wrapper)
+          if !result[:payment].nil? and result[:payment].success
+            @authorization_code = result[:payment].authorization_code
+          else
+            @message = result[:message]
+          end
+        end
+      end
+
+      if @error_message.nil?
+        Rails.logger.info 'ErpInvoicing::SmsController#submit_payment called: payment successful'
+      else
+        Rails.logger.error 'ErpInvoicing::SmsController#submit_payment called: payment failed'
+      end
+    end
+
+
+    def render_false
+      render :json => {:success => false}
+    end
+
+    def render_true
+      render :json => {:success => true}
+    end
+
+    def allow_by_ip
+      Rails.logger.info "ErpInvoicing::SmsController#allow_by_ip called: request from #{request.remote_ip}"
+      if request.remote_ip != SMS_SERVICE_IP
+        redirect_to '/'
+        flash.now[:notice] = "Access denied!"
+        return false
+      end
+    end
+
+
+  end
+end

data/app/models/billing_account.rb

@@ -0,0 +1,204 @@
+class BillingAccount < ActiveRecord::Base
+  has_relational_dynamic_attributes
+  acts_as_financial_txn_account
+  
+
+  has_many :invoices, :dependent => :destroy do
+    def by_invoice_date
+      order('invoice_date desc')
+    end
+
+    def balance
+      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 has_recurring_payment_enabled?
+    !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 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
+
+    unless self.invoices.empty?
+      selected_payment_applications = (selected_payment_applications | self.invoices.collect{|item| item.get_payment_applications(status)}).flatten! unless (self.invoices.collect{|item| item.get_payment_applications(status)}.empty?)
+    end
+
+    selected_payment_applications
+  end
+
+  def has_outstanding_balance?
+    (outstanding_balance > 0)
+  end
+
+  def outstanding_balance
+    (balance - total_pending_payments)
+  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 and !self.invoices.empty?
+      self.invoices.by_invoice_date.last.payment_due
+    else
+      self.financial_txn_account.payment_due.amount
+    end
+  end
+
+  def payment_due=(amount, currency=Currency.usd)
+    currency = Currency.usd
+    if amount.is_a?(Array)
+      currency = amount.last
+      amount = amount.first
+    end
+    if self.financial_txn_account.payment_due
+      self.financial_txn_account.payment_due.amount = amount
+    else
+      self.financial_txn_account.payment_due = Money.create(:amount => amount, :currency => currency)
+    end
+    self.financial_txn_account.payment_due.save
+  end
+
+  def billing_date
+    unless self.invoices.empty?
+      current_invoice.invoice_date
+    else
+      self.attributes['billing_date']
+    end
+  end
+
+  #override due_date for invoice.invoice_date
+  def due_date
+    unless self.invoices.empty?
+      current_invoice.due_date
+    else
+      self.financial_txn_account.due_date
+    end
+  end
+
+  #override balance_date for today if calculate_balance is set to true
+  def balance_date
+    if self.calculate_balance
+      Date.today
+    else
+      unless self.invoices.empty?
+        current_invoice.invoice_date
+      else
+        self.financial_txn_account.balance_date
+      end
+    end
+  end
+
+  #override balance to use invoices is calculate_balance is set to true
+  def balance
+    if self.calculate_balance
+      self.invoices.balance
+    else
+      (self.financial_txn_account.balance.amount - self.total_payments)
+    end
+  end
+
+  def balance=(amount, currency=Currency.usd)
+    if amount.is_a?(Array)
+      currency = amount.last
+      amount = amount.first
+    end
+    if self.financial_txn_account.balance
+      self.financial_txn_account.balance.amount = amount
+    else
+      self.financial_txn_account.balance = Money.create(:amount => amount, :currency => currency)
+    end
+    self.financial_txn_account.balance.save
+  end
+
+  def current_invoice
+    self.invoices.by_invoice_date.last
+  end
+
+  def send_sms_notification
+    primary_party = self.find_parties_by_role('primary').first
+    from_party = Party.find_by_description('Compass AE')
+    from_number = from_party.default_phone_number
+    to_number = primary_party.billing_phone_number
+
+    # prevent multiple sms notifications being sent within the time window
+    previous_cmm_evt = CommunicationEvent.find_by_sql("SELECT * FROM communication_events
+                                    JOIN phone_numbers from_phone ON from_contact_mechanism_id=from_phone.id
+                                    JOIN phone_numbers to_phone ON to_contact_mechanism_id=to_phone.id
+                                    WHERE from_contact_mechanism_type = 'PhoneNumber' 
+                                    AND from_contact_mechanism_type='PhoneNumber'
+                                    AND from_phone.phone_number = '#{from_number.phone_number.to_s}'
+                                    AND (to_phone.phone_number = '#{to_number.phone_number.to_s}' OR to_phone.phone_number = '#{to_number.phone_number[1..to_number.phone_number.length]}')
+                                    AND communication_events.created_at > '#{SMS_TIME_WINDOW.minutes.ago.to_s}'
+                                    ORDER BY communication_events.created_at DESC").first
+
+    Rails.logger.info 'not sending sms notification, one has already been sent within time window' if !previous_cmm_evt.nil?
+
+    unless primary_party.billing_phone_number.nil? or !previous_cmm_evt.nil?
+      message = SMS_NOTIFICATION_MESSAGE.gsub('payment_due',self.payment_due.to_s)
+      
+
+      # get cmm event purpose type
+      sms_purpose = CommEvtPurposeType.find_by_internal_identifier('sms_notification')
+
+      # create cmm event
+      cmm_evt = CommunicationEvent.new
+      cmm_evt.short_description = 'SMS Notification'
+      cmm_evt.from_role = RoleType.find_by_internal_identifier('application')
+      cmm_evt.from_party = from_party
+      cmm_evt.from_contact_mechanism = from_number
+      cmm_evt.comm_evt_purpose_types << sms_purpose
+      cmm_evt.to_contact_mechanism = to_number
+      cmm_evt.to_role = RoleType.find_by_internal_identifier('customer')
+      cmm_evt.to_party = primary_party
+      cmm_evt.case_id = self.id
+      cmm_evt.notes = "From Number: #{from_number}, To Number: #{to_number}, Message: #{message}"
+
+      clikatell = ErpTechSvcs::SmsWrapper::Clickatell.new
+      cmm_evt.external_identifier = clikatell.send_message(to_number.phone_number, message, :mo => 1, :from => from_number.phone_number)
+
+      unless cmm_evt.external_identifier.nil?
+        cmm_evt.save
+        return true
+      else
+        return false
+      end
+    end
+  end
+
+  def send_email_notification
+    primary_party = self.find_parties_by_role('primary').first
+    unless primary_party.billing_email_address.nil?
+      #send email
+    end
+  end
+
+end

data/app/models/extensions/document.rb

@@ -0,0 +1,5 @@
+Document.class_eval do
+  has_many_polymorphic :documented_models,
+    :through => :valid_documents,
+    :models => [:billing_account]
+end

data/app/models/extensions/financial_txn.rb

@@ -0,0 +1,5 @@
+FinancialTxn.class_eval do
+
+	has_many :payment_applications, :dependent => :destroy
+      
+end

data/app/models/extensions/party.rb

@@ -0,0 +1,10 @@
+Party.class_eval do
+
+  has_many 	  :invoice_party_roles, :dependent => :destroy
+	has_many	  :invoices, :through => :invoice_party_roles
+
+  def billing_accounts
+    self.biz_txn_acct_roots.where('biz_txn_acct_type = ?', 'FinancialTxnAccount').collect(&:account).collect(&:financial_account)
+  end
+
+end

data/app/models/invoice.rb

@@ -1,16 +1,109 @@
 class Invoice < ActiveRecord::Base
+  acts_as_document
   
+  belongs_to  :billing_account
   belongs_to	:invoice_type
-	has_many 	  :invoice_items
-	has_many 	  :invoice_party_roles
-	has_many	  :parties, :through => :invoice_party_roles
-	
-	#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
+  belongs_to  :invoice_payment_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?}
+    end
+    def pending
+      all.select{|item| item.is_pending?}
+    end
+  end
+  has_many 	  :invoice_items, :dependent => :destroy do
+    def by_date
+      order('created_at')
+    end
 
+    def unpaid
+      select{|item| item.balance > 0 }
+    end
+  end
+  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)
+    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
+
+    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?)
+    end
+    
+    selected_payment_applications
+  end
+
+  def balance
+    (self.payment_due - self.total_payments)
+  end
+
+  def payment_due
+    self.items.all.sum(&:total_amount)
+  end
+
+  def total_payments
+    self.get_payment_applications(:successful).sum{|item| item.money.amount}
+  end
+
+  def transactions
+    transactions = []
+
+    self.items.each do |item|
+      transactions << {
+        :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)
+      }
+    end
+
+    transactions.sort_by{|item| [item[:date]]}
+  end
+
+  def add_party_with_role_type(party, role_type)
+    self.invoice_party_roles << InvoicePartyRole.create(:party => party, :role_type => convert_role_type(role_type))
+    self.save
+  end
+
+  def find_parties_by_role_type(role_type)
+    self.invoice_party_roles.where('role_type_id = ?', convert_role_type(role_type).id).all.collect(&:party)
+  end
+
+  private
+
+  def convert_role_type(role_type)
+    role_type = RoleType.iid(role_type) if role_type.is_a? String
+    raise "Role type does not exist" if role_type.nil?
+
+    role_type
+  end
 	
 end

data/app/models/invoice_item.rb

@@ -2,12 +2,45 @@ class InvoiceItem < ActiveRecord::Base
 
 	belongs_to 	:agreement
 	belongs_to	:agreement_item_type
-	
   belongs_to  :invoiceable_item, :polymorphic => true
 
 	#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
+  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
 
+  def has_payments?(status)
+    selected_payment_applications = self.get_payment_applications(status)
+    !(selected_payment_applications.nil? or selected_payment_applications.empty?)
+  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
+    end
+  end
+
+  def total_amount
+    (self.amount * self.quantity)
+  end
+
+   def total_payments
+    self.get_payment_applications(:successful).sum{|item| item.money.amount}
+  end
+
+  def balance
+    self.total_amount - self.total_payments
+  end
 
 end

data/app/models/invoice_payment_strategy_type.rb

@@ -0,0 +1,5 @@
+class InvoicePaymentStrategyType < ActiveRecord::Base
+  acts_as_erp_type
+
+  has_many :invoices
+end

data/app/models/invoice_payment_term.rb

@@ -0,0 +1,4 @@
+class InvoicePaymentTerm < ActiveRecord::Base
+  has_one    :invoice_payment_term_type
+  belongs_to :invoice_payment_term_set
+end

data/app/models/invoice_payment_term_set.rb

@@ -0,0 +1,6 @@
+class InvoicePaymentTermSet < ActiveRecord::Base
+  belongs_to :invoice
+  has_many   :invoice_payment_terms
+
+  alias :payment_terms :invoice_payment_terms
+end

data/app/models/invoice_payment_term_type.rb

@@ -0,0 +1,3 @@
+class InvoicePaymentTermType < ActiveRecord::Base
+  has_many :invoice_payment_terms
+end

data/app/models/payment_application.rb

@@ -1,6 +1,11 @@
 class PaymentApplication < ActiveRecord::Base
   
-  belongs_to  :payment
+  belongs_to  :financial_txn, :dependent => :destroy
   belongs_to  :payment_applied_to, :polymorphic => true
+  belongs_to  :money, :foreign_key => 'applied_money_amount_id', :dependent => :destroy
+
+  def is_pending?
+    (self.financial_txn.is_scheduled? or self.financial_txn.is_pending?) unless self.financial_txn.nil?
+  end
   
 end

data/app/models/recurring_payment.rb

@@ -0,0 +1,40 @@
+class RecurringPayment < ActiveRecord::Base
+  belongs_to :billing_account
+  belongs_to :payment_account, :polymorphic => true
+
+  def schedule_payment(date)
+    unless self.payment_account.nil?
+      if self.billing_account.has_outstanding_balance?
+        payment_amount = self.billing_account.outstanding_balance
+        if payment_amount < self.pay_up_to_amount
+
+          money = Money.create(
+            :amount => payment_amount.to_f,
+            :description => "AutoPayment",
+            :currency => Currency.usd
+          )
+          financial_txn = FinancialTxn.create(
+            :apply_date => date,
+            :money => money
+          )
+          financial_txn.description = "AutoPayment"
+          financial_txn.account = self.payment_account.account_root
+          financial_txn.save
+
+          PaymentApplication.create(
+            :financial_txn => financial_txn,
+            :payment_applied_to => self.billing_account,
+            :money => money,
+            :comment => "AutoPayment"
+          )
+
+          #make sure the payment is below the pay_up_to_amount
+        else
+          #notify payment greater than amount in autopay
+        end
+      end#make sure the account has an outstanding balance
+    end#make sure it has a payment account
+    
+  end
+
+end

data/config/routes.rb

@@ -1,6 +1,13 @@
 ErpInvoicing::Engine.routes.draw do
 
+  match '/sms/receive_response' => "sms#receive_response"
+
   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
+  #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

data/db/data_migrations/20111121153349_create_bill_pay_organizer_application.rb

@@ -2,7 +2,7 @@ class CreateBillPayOrganizerApplication
   def self.up
     OrganizerApplication.create(
       :description => 'Bill Pay',
-      :icon => 'icon-credit_cards',
+      :icon => 'icon-creditcards',
       :javascript_class_name => 'Compass.ErpApp.Organizer.Applications.BillPay.Base',
       :internal_identifier => 'bill_pay'
     )

data/db/data_migrations/20120118181839_create_invoice_management_desktop_application.rb

@@ -0,0 +1,26 @@
+class CreateInvoiceManagementDesktopApplication
+  def self.up
+    app = DesktopApplication.create(
+      :description => 'Invoice Management',
+      :icon => 'icon-creditcards',
+      :javascript_class_name => 'Compass.ErpApp.Desktop.Applications.InvoiceManagement',
+      :internal_identifier => 'invoice_management',
+      :shortcut_id => 'invoice_management-win'
+    )
+
+    app.save
+
+    pt1 = PreferenceType.iid('desktop_shortcut')
+    pt1.preferenced_records << app
+    pt1.save
+
+    pt2 = PreferenceType.iid('autoload_application')
+    pt2.preferenced_records << app
+    pt2.save
+    
+  end
+
+  def self.down
+    DesktopApplication.destroy_all(['internal_identifier = ?','invoice_management'])
+  end
+end