billing 0.0.4b → 0.0.4c

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9bfd4fff3c8d6fb3af8ebcde11009896843be267
-  data.tar.gz: 2e7ee0f1c84ad0cb88893903661693b9a2fa1029
+  metadata.gz: f51a39d7e8dc5cadc3f1bbacc4db572251326332
+  data.tar.gz: 4ce5c7237f1ca1feedf1ac81dcbae83cbcc79325
 SHA512:
-  metadata.gz: 901e48a6a48b9db74176689865ddd91d76e6d3a433019156f5c20fe9e17c5c3d5fed85e7f986a7585b3c741a81b095ce6c43384e84e8eec2f7f50bdfc59f5d93
-  data.tar.gz: b6e89ea5dbfa2a25e09c3682e94249c70672d0c7bc5a0d40ee8343e117bd7d6e3a03fe9dd97e0486e70302d49b33bf6bd8539e49f28696c409a27ade53ae4e97
+  metadata.gz: 00864e10f3eb01c9a771972dd05481ba46ffb8bc4268c1f2aaf742cecc87a2a52c16a9d8e00251a903eb573a15b1653c5dc73f73ae023cc5d40f0f8c45a7ec79
+  data.tar.gz: 4c82fd8ae9adfde0925522873f38721fb5a68d946960256708398d82c4c2423dbd356c7b95f4ab43069761cc3c54ffd7db99c04384b34334a0e6c8ae62928b34

data/app/models/billing/{account.rb → bill.rb}

@@ -1,5 +1,5 @@
 module Billing
-  class Account < ActiveRecord::Base
+  class Bill < ActiveRecord::Base
     acts_as_paranoid if respond_to?(:acts_as_paranoid)
     has_paper_trail class_name: 'Billing::Version' if respond_to?(:has_paper_trail)
       
@@ -11,11 +11,11 @@ module Billing
     monetize :balance_cents
     
     belongs_to :billable, polymorphic: true
-    has_many :charges, inverse_of: :account, dependent: :destroy
-    has_many :modifiers, inverse_of: :account, dependent: :destroy
-    has_many :payments, inverse_of: :account, dependent: :restrict_with_error
-    belongs_to :origin, inverse_of: :accounts
-    belongs_to :report, inverse_of: :accounts
+    has_many :charges, inverse_of: :bill, dependent: :destroy
+    has_many :modifiers, inverse_of: :bill, dependent: :destroy
+    has_many :payments, inverse_of: :bill, dependent: :restrict_with_error
+    belongs_to :origin, inverse_of: :bills
+    belongs_to :report, inverse_of: :bills
     
     if defined? Extface
       belongs_to :extface_job, class_name: 'Extface::Job'
@@ -28,11 +28,14 @@ module Billing
     scope :unpaid, -> { where(arel_table[:balance_cents].lt(0)) }
     scope :open, -> { where.not(balance_cents: 0) }
     scope :partially_paid, -> { where.not( payments_sum_cents: 0, balance_cents: 0 ) }
+    scope :for_report, -> { where(balance_cents: 0 ,report_id: nil) }
     
-    before_validation :update_sumaries
-    
-    before_save on: :create do
-      self.number = "#{billable.id}:#{billable.billing_accounts.count}"
+    before_validation do
+      update_sumaries
+      self.origin = payments.first.try(:origin) unless origin.present? or payments.many?
+    end
+    before_create do
+      self.number = "#{billable.id}:#{billable.billing_bills.count}"
       self.name = "B:#{number}" if name.nil?
     end
     before_save :perform_autofin, if: :becomes_paid?
@@ -45,18 +48,15 @@ module Billing
       :payments_of_diff_fiscalization?, :multiple_cash_payments?, if: :has_payments?
     
     def charge(*args)
-      c = charges.new Charge.args(*args)
-      c if c.save
+      charges.wild *args
     end
     
     def modify(*args)
-      m = modifiers.new Modifier.args(*args)
-      m if m.save
+      modifiers.wild *args
     end
     
     def pay(*args)
-      p = build_typed_payment Payment.args(*args)
-      p if p.save
+      payments.wild *args
     end
     
     def modifier_items
@@ -91,24 +91,29 @@ module Billing
 
     private
       def calculate_modifiers
+        charges_a = charges.to_a
         @modifier_items = ModifierItems.new.tap() do |items|
-          modifiers.each do |modifier|
-            if charge = modifier.charge
-              charge.value = modifier.percent_ratio.nil? ? modifier.fixed_value : (charge.price * modifier.percent_ratio)
-              items << Charge.new(price: charge.value, chargable: charge)
-            else
-              items << Charge.new(price: modifier.percent_ratio.nil? ? modifier.fixed_value : (charges.to_a.sum(&:price).to_money * modifier.percent_ratio))
-            end
+          modifiers.select{ |m| m.charge.present? }.each do |charge_modifier|
+            charge = charges_a.find{ |c| c == charge_modifier.charge }
+            mod_value = charge_modifier.percent_ratio.nil? ? charge_modifier.fixed_value : (charge_modifier.charge.price * charge_modifier.percent_ratio)
+            p mod_value
+            charge.value = charge.price + mod_value
+            #p charge.value
+            #p "-"
+            items << Charge.new(price: mod_value, chargable: charge)
+          end
+          modifiers.select{ |m| m.charge.nil? }.each do |global_modifier|
+            items << Charge.new(price: global_modifier.percent_ratio.nil? ? global_modifier.fixed_value : (charges_a.sum(&:value).to_money * global_modifier.percent_ratio))
           end
         end
       end
       def update_sumaries
-        self.charges_sum = charges.to_a.sum(&:price).to_money
         calculate_modifiers
-        self.discounts_sum = -@modifier_items.discounts.sum(&:price).to_money
-        self.surcharges_sum = @modifier_items.surcharges.sum(&:price).to_money
-        self.payments_sum = payments.to_a.sum(&:value).to_money
-        self.total = charges_sum + surcharges_sum - discounts_sum
+        self.charges_sum = charges.to_a.sum(0.to_money, &:value).to_money
+        self.discounts_sum = @modifier_items.discounts.sum(0.to_money, &:price).to_money
+        self.surcharges_sum = @modifier_items.surcharges.sum(0.to_money, &:price).to_money
+        self.payments_sum = payments.to_a.sum(0.to_money, &:value).to_money
+        self.total = charges.to_a.sum(0.to_money, &:price) + surcharges_sum + discounts_sum
         self.balance = payments_sum - total
       end
       
@@ -141,5 +146,6 @@ module Billing
       def fiscalizable?
         payments.select(&:fiscal?).any?
       end
+
   end
 end

data/app/models/billing/charge.rb

@@ -1,34 +1,48 @@
 module Billing
   class Charge < ActiveRecord::Base
-    include AccountItem
-    belongs_to :account, inverse_of: :charges, validate: true
+    include BillItem
+    
+    attr_accessor :tax_group, :plu, :department
+    
+    belongs_to :bill, inverse_of: :charges, validate: true
     belongs_to :chargable, polymorphic: true
     belongs_to :origin, inverse_of: :charges
     has_one :modifier, inverse_of: :charge
 
-    monetize :price_cents
+    monetize :price_cents, with_model_currency: :price_currency
     monetize :value_cents
     
-    delegate :paid?, to: :account
+    delegate :paid?, to: :bill
     
-    scope :unpaid, -> { joins(:account).where.not(billing_accounts: { balance_cents: 0}) }
-    scope :paid, -> { joins(:account).where(billing_accounts: { balance_cents: 0}) }
+    scope :unpaid, -> { joins(:bill).where.not(billing_bills: { balance_cents: 0}) }
+    scope :paid, -> { joins(:bill).where(billing_bills: { balance_cents: 0}) }
     scope :in_period, lambda {|from, to| where(revenue_at: from..to) }
     
     validates_presence_of :price
     validates_numericality_of :value, greater_than_or_equal_to: 0
     
-    before_save do
-      self.value = price unless modifier.present? #FIXME global account modifier lost
+    after_initialize do
+      self.value = price #unless modifier.present? #bill validation will update modified value
     end
     
     class << self
-      def args(*args)
+      include Billing::BillTextParser
+      def wild_args(*args)
         case when args.blank? || args.first.is_a?(Hash) then
-          {}.merge(*args)
+          return {}.merge(*args)
+        when args.size == 1 && args.first.is_a?(String) then
+          if match = args.shift.match(/(\d+[.,]\d+\*|\d+\*|)(\d+[.,]\d+[A-Z]*|\d+[A-Z]*|)(#\d+|)(@\d+|)([+-]\d+[.,]\d+\%?|[+-]\d+\%?|)(\/\S+|)/)
+            qty_s, price_s, plu_s, tax_group_s, mod_s, text = match.captures
+            return {
+              qty: parse_qty(qty_s),
+              price: price_s.to_money,
+              plu: parse_plu(plu_s),
+              name: parse_text(text)
+            }
+          end
         else
           h = { price: args.shift.to_money }
-          args.any? ? h.merge(*args) : h
+          return args.any? ? h.merge(*args) : h
         end
       end
     end

data/app/models/billing/modifier.rb

@@ -1,13 +1,13 @@
 module Billing
   class Modifier < ActiveRecord::Base
-    include AccountItem
-    belongs_to :account, inverse_of: :modifiers, validate: true
+    include BillItem
+    belongs_to :bill, inverse_of: :modifiers, validate: true
     belongs_to :charge, inverse_of: :modifier
     monetize :fixed_value_cents
     
     validate :percent_or_value
-    validates_uniqueness_of :charge, scope: :account_id, allow_nil: true
-    validates_uniqueness_of :account, scope: :charge_id
+    validates_uniqueness_of :charge, scope: :bill_id, allow_nil: true
+    validates_uniqueness_of :bill, scope: :charge_id
     
     private
       def percent_or_value
@@ -16,7 +16,7 @@ module Billing
       end
       
     class << self
-      def args(*args)
+      def wild_args(*args)
         case when args.blank? || args.first.kind_of?(Hash) then
           {}.merge(*args)
         when args.first.kind_of?(String) then

data/app/models/billing/origin.rb

@@ -1,8 +1,8 @@
 module Billing
   class Origin < ActiveRecord::Base
-    has_many :accounts, inverse_of: :origin
+    has_many :bills, inverse_of: :origin
     has_many :charges, inverse_of: :origin
-    has_many :payments, through: :accounts
+    has_many :payments, through: :bills
     if defined? Extface
       belongs_to :fiscal_device, ->(o) { where( extfaceable_id: o.master_id ) }, class_name: 'Extface::Device'
     end

data/app/models/billing/payment.rb

@@ -5,32 +5,28 @@ module Billing
     PAYPAL_EXPRESS = 'Billing::PaypalExpress'.freeze
     PAYMENT_MODELS = [PAYMENT_WITH_TYPE, PAYMENT_EXTERNAL, PAYPAL_EXPRESS].freeze
     
-    include AccountItem
+    include BillItem
     
     attr_writer :origin
     attr_accessor :origin_id
     monetize :value_cents
 
-    belongs_to :account, inverse_of: :payments, validate: true
+    belongs_to :bill, inverse_of: :payments, validate: true
     
     scope :in_period, lambda {|from, to| where(created_at: from..to) }
-    scope :for_report, -> { joins(:account).where(billing_accounts: { balance_cents: 0 ,report_id: nil }) }
+    scope :for_report, -> { joins(:bill).where(billing_bills: { balance_cents: 0 ,report_id: nil }) }
     
     if defined? Extface
       belongs_to :extface_job, class_name: 'Extface::Job'
     end
     
-    delegate :billable, to: :account
+    delegate :billable, to: :bill
 
     validates_numericality_of :value, greater_than_or_equal_to: 0
     validates :type, inclusion: { in: PAYMENT_MODELS }
     
     after_initialize on: :create do
-      self.value = -account.try(:balance) if value.zero?
-    end
-    
-    before_validation do
-      account.origin = origin unless account.origin and account.payments.many?
+      self.value = -bill.try(:balance) if value.zero?
     end
     
     def fiscal?; false; end
@@ -43,7 +39,7 @@ module Billing
     
     private
       class << self
-        def args(*args)
+        def wild_args(*args)
           h = {}
           case when args.blank? || args.first.kind_of?(Hash) then
             args.blank? ? h : h.merge(*args)

data/app/models/billing/payment_with_type.rb

@@ -22,7 +22,7 @@ module Billing
         if pt = billable.try(:default_payment_type)
           pt
         else
-          account.payment_types.try(:first) unless account.payment_types.many?
+          bill.payment_types.try(:first) unless bill.payment_types.many?
         end
       end
     

data/app/models/billing/report.rb

@@ -7,22 +7,24 @@ module Billing
       
     has_paper_trail class_name: 'Billing::Version'
     belongs_to :origin, inverse_of: :reports
-    has_many :accounts, inverse_of: :report, autosave: true
+    has_many :bills, inverse_of: :report, autosave: true
     belongs_to :extface_job, class_name: 'Extface::Job'
-    has_many :payments, through: :accounts
+    has_many :payments, through: :bills
 
     monetize :payments_sum_cents
     monetize :payments_cash_cents
     monetize :payments_fiscal_cents
     
     validates_presence_of :origin
-    validates_absence_of :partially_paid_accounts?
+    validates_absence_of :partially_paid_bills?
     validates :f_operation, inclusion: { in: F_OPERATIONS }, allow_nil: true
     validates_presence_of :f_period_from, :f_period_to, if: :fiscal_period_report?
     
-    before_validation :set_report_to_accounts
+    before_validation :set_report_to_bills
     before_create :update_summary
     
+    scope :in_period, lambda {|from, to| where(created_at: from..to) }
+    
     
     def fiscalization
       if origin.fiscal_device.present?
@@ -37,14 +39,14 @@ module Billing
         f_operation == FISCAL_PERIOD_REPORT
       end
       
-      def set_report_to_accounts
-        self.accounts << origin.accounts.select(&:paid?) if zeroing?
+      def set_report_to_bills
+        self.bills << origin.bills.for_report if zeroing?
       end
       
       def update_summary
-        self.payments_sum = accounts.to_a.sum(Money.new(0, 'USD'), &:payments_sum)
-        self.payments_cash = payments.select{ |p| p.try(:cash?) }.sum(Money.new(0, 'USD'), &:value)
-        self.payments_fiscal = payments.select{ |p| p.try(:fiscal?) }.sum(Money.new(0, 'USD'), &:value)
+        self.payments_sum = bills.to_a.sum(Money.new(0, 'USD'), &:payments_sum)
+        self.payments_cash = bills.collect(&:payments).flatten.select{ |p| p.try(:cash?) }.sum(Money.new(0, 'USD'), &:value)
+        self.payments_fiscal = bills.collect(&:payments).flatten.select{ |p| p.try(:fiscal?) }.sum(Money.new(0, 'USD'), &:value)
         perform_fiscal_job
       end
       
@@ -59,8 +61,8 @@ module Billing
         end
       end
       
-      def partially_paid_accounts?
-        accounts.partially_paid.any?
+      def partially_paid_bills?
+        bills.partially_paid.any?
       end
   end
 end

data/app/models/concerns/billing/{account_item.rb → bill_item.rb}

@@ -1,17 +1,16 @@
 module Billing
-  module AccountItem
+  module BillItem
     extend ActiveSupport::Concern
     
     included do
       acts_as_paranoid if respond_to?(:acts_as_paranoid)
       has_paper_trail class_name: 'Billing::Version' if respond_to?(:has_paper_trail)
       
-      delegate :save, to: :account, prefix: :account
-      delegate :origins, :payment_types, to: :account
+      delegate :save, to: :bill, prefix: :bill
+      delegate :origins, :payment_types, to: :bill
       
-      after_save :account_save
-      
-      validates_presence_of :account
+      after_save :bill_save
+      after_destroy :bill_save
     end
 
   end

data/app/models/concerns/billing/bill_text_parser.rb

@@ -0,0 +1,18 @@
+module Billing
+  module BillTextParser
+
+    def parse_qty(qty_s)
+      nil
+    end
+    
+    def parse_plu(plu_s)
+      nil
+    end
+    
+    def parse_text(text)
+      #p text
+      text[1..-1] if text
+    end
+
+  end
+end

data/config/initializers/money.rb

@@ -0,0 +1,67 @@
+# encoding : utf-8
+
+MoneyRails.configure do |config|
+
+  # To set the default currency
+  #
+  # config.default_currency = :usd
+
+  # Set default bank object
+  #
+  # Example:
+  # config.default_bank = EuCentralBank.new
+
+  # Add exchange rates to current money bank object.
+  # (The conversion rate refers to one direction only)
+  #
+  # Example:
+  # config.add_rate "USD", "CAD", 1.24515
+  # config.add_rate "CAD", "USD", 0.803115
+
+  # To handle the inclusion of validations for monetized fields
+  # The default value is true
+  #
+  # config.include_validations = true
+
+  # Default ActiveRecord migration configuration values for columns:
+  #
+  # config.amount_column = { prefix: '',           # column name prefix
+  #                          postfix: '_cents',    # column name  postfix
+  #                          column_name: nil,     # full column name (overrides prefix, postfix and accessor name)
+  #                          type: :integer,       # column type
+  #                          present: true,        # column will be created
+  #                          null: false,          # other options will be treated as column options
+  #                          default: 0
+  #                        }
+  #
+  # config.currency_column = { prefix: '',
+  #                            postfix: '_currency',
+  #                            column_name: nil,
+  #                            type: :string,
+  #                            present: true,
+  #                            null: false,
+  #                            default: 'USD'
+  #                          }
+
+  # Register a custom currency
+  #
+  # Example:
+  # config.register_currency = {
+  #   :priority            => 1,
+  #   :iso_code            => "EU4",
+  #   :name                => "Euro with subunit of 4 digits",
+  #   :symbol              => "€",
+  #   :symbol_first        => true,
+  #   :subunit             => "Subcent",
+  #   :subunit_to_unit     => 10000,
+  #   :thousands_separator => ".",
+  #   :decimal_mark        => ","
+  # }
+
+  # Set money formatted output globally.
+  # Default value is nil meaning "ignore this option".
+  # Options are nil, true, false.
+  #
+  # config.no_cents_if_whole = nil
+  # config.symbol = nil
+end