erp_invoicing 3.1.0 → 4.0.0

data/app/controllers/erp_invoicing/erp_app/organizer/bill_pay/accounts_controller.rb

@@ -1,166 +0,0 @@
-module ErpInvoicing
-  module ErpApp
-    module Organizer
-      module BillPay
-        class AccountsController < ::ErpApp::Organizer::BaseController
-
-          class Helper
-            include Singleton
-            include ActionView::Helpers::NumberHelper
-          end
-
-          def help
-            Helper.instance
-          end
-
-          def index
-            accounts = {:totalCount => 1, :accounts => [{
-                  :id => 1,
-                  :account_number => '123455667',
-                  :payment_due => help.number_to_currency(33.45),
-                  :billing_date => '10/31/2011',
-                  :due_date => '11/15/2011',
-                  :account_id => 1,
-                  :party_id => 1
-                }]}
-
-            render :json => accounts
-          end
-
-          def transactions
-            transactions = {:totalCount => 2, :transactions => [
-                {
-                  :date => '10/10/2011',
-                  :description => 'Monthly Billing Amount',
-                  :amount => help.number_to_currency(50.00)
-                },
-                {
-                  :date => '10/15/2011',
-                  :description => 'Payment Recieved',
-                  :amount => help.number_to_currency(-50.00)
-                }
-              ]}
-
-            render :json => transactions
-          end
-
-          def make_payment_on_account
-            #get configuration
-
-            @message = nil
-
-            #get subscription selection if it is there
-            @subscription_selection = get_subscription_selection if params[:subscription_selection]
-
-            #get convenience_fee if it is there
-            @convenience_fee = get_convenience_fee if params[:convenience_fee]
-
-            #get additional payments
-            #@aditional_payments = get_additional_payments
-
-            @billing_account_payment_amts = get_billing_account_amounts
-            Rails.logger.debug("##### Billing Acct Payments: #{@billing_account_payment_amts}")
-            @payment_account_root = BizTxnAcctRoot.find(params[:payment_account_id])
-            @payment_account = @payment_account_root.account
-            @payment_date = params[:payment_date]
-            @total_payment = params[:total_payment]
-
-            money = Money.create(
-              :amount => @total_payment.to_d,
-              :description => "Online Payment",
-              :currency => Currency.usd
-            )
-            financial_txn = FinancialTxn.create(
-              :apply_date => Date.strptime(@payment_date,"%m/%d/%Y"),
-              :money => money
-            )
-            financial_txn.description = "Online Payment"
-            financial_txn.account = @payment_account_root
-            financial_txn.save
-
-            @billing_account_payment_amts.each do |hash|
-              amount = hash[:amount].to_d rescue 0
-              if amount > 0
-                comment = (params[:short_payment_comment] and hash[:short_payment]) ? params[:short_payment_comment] : nil
-                PaymentApplication.create(
-                  :financial_txn => financial_txn,
-                  :payment_applied_to => hash[:billing_account],
-                  :money => Money.create(:amount => amount),
-                  :comment => comment
-                )
-              end
-            end
-
-            #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
-                
-                if financial_txn.apply_date == Date.today
-                  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
-                end
-              when "CreditCardAccount"
-                financial_txn.txn_type = BizTxnType.cc_sale
-                financial_txn.save
-                
-                if financial_txn.apply_date == Date.today
-                  result = @payment_account.purchase(financial_txn, params[:cvv], 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 @message.nil?
-              render :json => {:success => true, :message => "Payment Successful!" }
-            else 
-              render :json => {:success => false, :message => @message }
-            end
-          end
-
-          def payment_accounts
-            party = Party.find(params[:party_id])
-
-            results = party.accounts.map do |acct|
-              if acct.biz_txn_acct_type == "CreditCardAccount" || acct.biz_txn_acct_type == 'BankAccount'
-                { :id => acct.id,
-                  :description => acct.description,
-                  :account_type => acct.biz_txn_acct_type
-                }
-              end
-            end
-
-            results.reject!{|x| x.nil?}
-
-            render :json => results
-          end
-
-          def generate_statement
-
-          end
-          def get_billing_account_amounts
-            billing_account_payment_amts = []
-            billing_account = BillingAccount.find(params["billing_account_id"])
-            amount = params[:total_payment]
-            billing_account_payment_amts << {:billing_account => billing_account, :amount => amount, :short_payment => (amount.to_d < billing_account.balance)}
-
-            billing_account_payment_amts
-          end
-
-        end
-      end#BillPay
-    end#Organizer
-  end#ErpApp
-end#ErpInvoicing
-
-
-

data/app/controllers/erp_invoicing/erp_app/organizer/bill_pay/base_controller.rb

@@ -1,22 +0,0 @@
-module ErpInvoicing
-  module ErpApp
-    module Organizer
-      module BillPay
-        class BaseController < ::ErpApp::Organizer::BaseController
-
-          def menu
-            menu = []
-
-            menu << {:text => 'Bill Pay', :leaf => true, :iconCls => 'icon-creditcards', :applicationCardId => "billpay-application"}
-
-            render :json => menu
-          end
-
-        end
-      end#BillPay
-    end#Organizer
-  end#ErpApp
-end#ErpInvoicing
-
-  
-

data/app/controllers/erp_invoicing/erp_app/shared/billing_accounts_controller.rb

@@ -1,111 +0,0 @@
-module ErpInvoicing
-  module ErpApp
-    module Shared
-      class BillingAccountsController < ::ErpApp::Desktop::BaseController
-        @@date_format = "%m/%d/%Y"
-
-        def index
-          render :json => if request.put?
-            update_billing_account
-          elsif request.post?
-            create_billing_account
-          elsif request.get?
-            get_billing_accounts
-          elsif request.delete?
-            delete_billing_account
-          end
-        end
-
-        def get_billing_accounts
-          result = {:success => true, :billing_accounts => [], :totalCount => 0}
-
-          sort_hash      = params[:sort].blank? ? {} : Hash.symbolize_keys(JSON.parse(params[:sort]).first)
-          sort           = sort_hash[:sort] || 'created_at'
-          dir            = sort_hash[:dir] || 'DESC'
-          limit          = params[:limit] || 50
-          start          = params[:start] || 0
-          party_id       = params[:party_id] || nil
-
-          billing_accounts = (party_id.blank? ? BillingAccount.scoped.includes(:financial_txn_account) : BillingAccount.scoped.includes(:financial_txn_account => {:biz_txn_acct_root => :biz_txn_acct_party_roles}))
-          billing_accounts = billing_accounts.where(:financial_txn_accounts => {:account_number => params[:account_number]}) unless params[:account_number].blank?
-          billing_accounts = billing_accounts.where(:financial_txn_accounts => {:biz_txn_acct_roots => {:biz_txn_acct_party_roles => {:party_id => party_id }}}) unless party_id.blank?
-          billing_accounts = billing_accounts.order("financial_txn_accounts.#{sort} #{dir}").limit(limit).offset(start)
-          result[:totalCount] = billing_accounts.count
-
-          result.tap do |result_tap|
-            result_tap[:billing_accounts] = billing_accounts.all.collect do |billing_account|
-              billing_account.to_hash(:only => [], :methods => [:id,:send_paper_bills,:payable_online,:account_number,:calculate_balance,:payment_due,:balance,:balance_date,:due_date])
-            end#end billing_accounts collect
-            result_tap[:totalCount] = BillingAccount.count(:all)
-          end#end result tap
-        end
-
-        def create_billing_account
-          if params[:billingAccount]
-            data = params[:billingAccount]
-          else
-            data = params
-            data[:due_date] = Date.strptime(params[:due_date], @@date_format)
-            data[:balance_date] = Date.strptime(params[:balance_date], @@date_format)
-          end
-
-          billing_account = BillingAccount.new
-          billing_account.account_number = data[:account_number]
-          billing_account.calculate_balance = data[:calculate_balance]
-          billing_account.payment_due = data[:payment_due]
-          billing_account.balance = data[:balance]
-          billing_account.due_date = data[:due_date]
-          billing_account.balance_date = data[:balance_date]
-          billing_account.payable_online = data[:payable_online]
-          billing_account.send_paper_bills = data[:send_paper_bills]
-
-          if params[:party_id]
-            party = Party.find(params[:party_id])
-            primary_role_type = BizTxnAcctPtyRtype.find_by_internal_identifier('primary')
-            billing_account.add_party_with_role(party, primary_role_type)
-          end
-
-          if billing_account.save
-            {:success => true, :billing_accounts => billing_account.to_hash(:only => [], :methods => [:id,:send_paper_bills,:payable_online,:account_number,:calculate_balance,:payment_due,:balance,:balance_date,:due_date])}
-          else
-            {:success => false}
-          end
-        end
-
-        def update_billing_account
-          if params[:billingAccount]
-            data = params[:billingAccount]
-          else
-            data = params
-            data[:due_date] = Date.strptime(params[:due_date], @@date_format)
-            data[:balance_date] = Date.strptime(params[:balance_date], @@date_format)
-          end
-
-          billing_account = BillingAccount.find(data[:id])
-            
-          billing_account.account_number = data[:account_number]
-          billing_account.calculate_balance = data[:calculate_balance]
-          billing_account.due_date = data[:due_date]
-          billing_account.balance_date = data[:balance_date]
-          billing_account.payable_online = data[:payable_online]
-          billing_account.send_paper_bills = data[:send_paper_bills]
-          billing_account.payment_due = data[:payment_due]
-          billing_account.balance = data[:balance]
-
-          if billing_account.save
-            {:success => true, :billing_accounts => billing_account.to_hash(:only => [], :methods => [:id,:send_paper_bills,:payable_online,:account_number,:calculate_balance,:payment_due,:balance,:balance_date,:due_date])}
-          else
-            {:success => false}
-          end
-        end
-
-        def delete_billing_account
-          BillingAccount.find(params[:id]).destroy
-
-          {:success => true}
-        end
-
-      end#BillingAccountsController
-    end#Shared
-  end#ErpApp
-end#ErpInvoicing

data/app/controllers/erp_invoicing/erp_app/shared/files_controller.rb

@@ -1,52 +0,0 @@
-module ErpInvoicing
-  module ErpApp
-    module Shared
-      class FilesController < ::ErpApp::Desktop::FileManager::BaseController
-        before_filter :set_invoice
-
-        def base_path
-          @base_path = File.join(@file_support.root, Rails.application.config.erp_tech_svcs.file_assets_location, 'documents', @invoice.invoice_number)
-        end
-
-        def upload_file
-          clear_files
-
-          result = {}
-          upload_path = params[:directory]
-          name = params[:name]
-          data = request.raw_post
-
-          begin
-            @invoice.add_file(data, File.join(base_path, name))
-            result = {:success => true}
-          rescue Exception=>ex
-            Rails.logger.error ex.message
-            Rails.logger.error ex.backtrace.join("\n")
-            result = {:success => false, :error => "Error uploading file."}
-          end
-
-          #the awesome uploader widget whats this to mime type text, leave it render :inline
-          render :inline => result.to_json
-        end
-
-        def set_invoice
-          @invoice = Invoice.find(params[:invoice_id])
-        end
-
-        def set_file_support
-          @file_support = ErpTechSvcs::FileSupport::Base.new(:storage => Rails.application.config.erp_tech_svcs.file_storage)
-        end
-
-        private
-
-        def clear_files
-          @invoice.files.each do |file|
-            result, message, is_folder = @file_support.delete_file(File.join(@file_support.root,file.directory,file.name))
-            file.destroy
-          end
-        end
-
-      end#FilesController
-    end#Shared
-  end#ErpApp
-end#ErpInvoicing

data/app/controllers/erp_invoicing/erp_app/shared/invoices_controller.rb

@@ -1,208 +0,0 @@
-module ErpInvoicing
-  module ErpApp
-    module Shared
-      class InvoicesController < ::ErpApp::Desktop::BaseController
-
-        def parties
-          render :json => {
-            :parties => Party.all.collect{|party|
-              {:id => party.id, :description => party.description}
-            }
-          }
-        end
-
-        def sms_notification
-          invoice = Invoice.find(params[:id])
-          if invoice.billing_account.send_sms_notification
-            render :json => {:success => true}
-          else
-            render :json => {:success => false}
-          end
-        end
-
-        def billing_accounts
-          render :json => {
-            :billing_accounts => BillingAccount.all.collect{|billing_account|
-              {:id => billing_account.id, :account_number => billing_account.account_number}
-            }
-          }
-        end
-
-        def email_invoice
-          invoice = Invoice.find(params[:id])
-          DocumentMailer.email_document(params[:to_email], invoice.document).deliver
-
-          render :json => {:success => true}
-        end
-
-        def print_invoice
-          invoice = Invoice.find(params[:id])
-          send_data(File.read(invoice.files.first.data.path), {type: 'application/pdf', disposition: 'inline'})
-        end
-
-        def invoices
-          render :json => if request.put?
-            #update_invoice #not implemented yet
-          elsif request.get?
-            get_invoices
-          elsif request.delete?
-            delete_invoice
-          end
-        end
-
-        def get_invoices
-          result = {:success => true, :invoices => [], :totalCount => 0}
-
-          sort_hash      = params[:sort].blank? ? {} : Hash.symbolize_keys(JSON.parse(params[:sort]).first)
-          sort           = sort_hash[:sort] || 'created_at'
-          dir            = sort_hash[:dir] || 'DESC'
-          limit          = params[:limit] || 50
-          start          = params[:start] || 0
-
-          invoices = Invoice.scoped
-          invoices = invoices.where('invoice_number = ?', params[:invoice_number]) unless params[:invoice_number].blank?
-          invoices = invoices.where('billing_account_id = ?', params[:billing_account_id]) unless params[:billing_account_id].blank?
-          invoices = invoices.order("#{sort} #{dir}").limit(limit).offset(start)
-          result[:totalCount] = invoices.count
-
-
-          invoices.all.each do |invoice|
-            result[:invoices] << {
-              :id => invoice.id,
-              :invoice_number => invoice.invoice_number,
-              :description => invoice.description,
-              :message => invoice.message,
-              :invoice_date => invoice.invoice_date,
-              :due_date => invoice.due_date,
-              :billing_account => invoice.billing_account.account_number,
-              :payment_due => invoice.payment_due
-              #:billed_to_party => (invoice.find_parties_by_role_type('billed_to').first.description rescue ''),
-              #:billed_from_party => (invoice.find_parties_by_role_type('billed_from').first.description rescue '')
-            }
-          end
-
-          result
-        end
-
-        def create_invoice
-          invoice_date = Date.strptime(params[:invoice_date],"%m/%d/%Y")
-          due_date = Date.strptime(params[:due_date],"%m/%d/%Y")
-
-          invoice = Invoice.new(
-            :invoice_number => params[:invoice_number],
-            :invoice_date => invoice_date,
-            :due_date => due_date,
-            :message => params[:message],
-            :description => params[:description]
-          )
-
-          if invoice.save
-            billing_account = BillingAccount.find(params[:billing_account_id])
-            billing_account.invoices << invoice
-            billing_account.save
-
-            render :json => {:success => true}
-          else
-
-            render :json => {:success => false}
-          end
-        end
-
-        def delete_invoice
-          Invoice.find(params[:id]).destroy
-
-          {:success => true}
-        end
-
-        def invoice_items
-          render :json => if request.post?
-            create_invoice_item
-          elsif request.put?
-            update_invoice_item
-          elsif request.get?
-            get_invoice_items
-          elsif request.delete?
-            delete_invoice_item
-          end
-        end
-
-        def create_invoice_item
-          data = params[:data]
-          invoice = Invoice.find(params[:invoice_id])
-          invoice_item = InvoiceItem.create(:amount => data[:amount].to_d, :quantity => data[:quantity], :item_description => data[:item_description])
-          invoice.items << invoice_item
-
-          {:success => true,
-            :invoice_items => {
-              :item_description => invoice_item.item_description,
-              :quantity => invoice_item.quantity,
-              :amount => invoice_item.amount,
-              :id => invoice_item.id,
-              :created_at => invoice_item.created_at
-            }
-          }
-        end
-
-        def update_invoice_item
-          data = params[:data]
-          invoice_item = InvoiceItem.find(data[:id])
-          invoice_item.amount = data[:amount].to_d
-          invoice_item.quantity = data[:quantity]
-          invoice_item.item_description = data[:item_description]
-          invoice_item.save
-
-          {:success => true,
-            :invoice_items => {
-              :item_description => invoice_item.item_description,
-              :quantity => invoice_item.quantity,
-              :amount => invoice_item.amount,
-              :id => invoice_item.id,
-              :created_at => invoice_item.created_at
-            }
-          }
-        end
-      
-        def get_invoice_items
-          result = {:success => true, :invoice_items => [], :totalCount => 0}
-
-          invoice = Invoice.find(params[:invoice_id])
-          result[:totalCount] = invoice.items.count
-          invoice.items.each do |item|
-            result[:invoice_items] << {
-              :item_description => item.item_description,
-              :quantity => item.quantity,
-              :amount => item.amount,
-              :id => item.id,
-              :created_at => item.created_at
-            }
-          end
-          result
-        end
-
-        def delete_invoice_item
-          InvoiceItem.find(params[:id]).destroy
-
-          {:success => true}
-        end
-
-        def invoice_payments
-          result = {:success => true, :payments => [], :totalCount => 0}
-
-          invoice = Invoice.find(params[:invoice_id])
-
-          invoice.payment_applications.each do |item|
-            result[:payments] << {
-              :payment_date => item.financial_txn.apply_date,
-              :post_date => item.financial_txn.captured_payment.created_at,
-              :payment_account => item.financial_txn.account.description,
-              :amount => item.financial_txn.money.amount
-            }
-          end
-
-          render :json => result
-        end
-
-      end#InvoicesController
-    end#Shared
-  end#ErpApp
-end#ErpInvoicing