billing 0.0.3 → 0.0.4a

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 747d5529859b70e9cc69f11653785d07d55b74a4
-  data.tar.gz: cfc4af81e2d5e2361a2bea947e7e2bb3cdc251f2
+  metadata.gz: b846f68aa64260bdc6f155667d462d2aebd32cab
+  data.tar.gz: b4f066fa781ea284213e6e62011406ac2590d1b3
 SHA512:
-  metadata.gz: c6c723a641929e19b86cd4bbfd1e175606036f055ba0112691c82c5e573b08bbc411133c6c577aef41655859e85a100a26b5ed60ed3c6e7bd8a6f3c6d9b7f535
-  data.tar.gz: c6d5372d0418f727050175f5eddf78c67f2cf903545722a593e4c9a6bb2bab8342c769cfd9a4d21a3741ed40053dfa4d3d341483ad157606e83c3381b72bebdf
+  metadata.gz: 732df67d2e5ff40579b1c508841cdd9873de3b6ce0c48ce622f11d3aac7cf1903a6d44152d7d3fbede4d8045df0a00015c7652ae0c7226df9132e6dc0ffe11b5
+  data.tar.gz: b3a9f712e2116801391bf16be73502d0a56a36b44bd3fa4c9115be7036a4e6d03d81cf6f21cd328f31ca53c917b14967be05959840d1a7ccf81a19ed1fbb1841

data/app/models/billing/account.rb

@@ -1,5 +1,8 @@
 module Billing
   class Account < ActiveRecord::Base
+    acts_as_paranoid if respond_to?(:acts_as_paranoid)
+    has_paper_trail class_name: 'Billing::Version' if respond_to?(:has_paper_trail)
+      
     monetize :charges_sum_cents
     monetize :discounts_sum_cents
     monetize :surcharges_sum_cents
@@ -8,15 +11,38 @@ module Billing
     monetize :balance_cents
     
     belongs_to :billable, polymorphic: true
-    has_many :charges, inverse_of: :account
-    has_many :modifiers, inverse_of: :account
-    has_many :payments, inverse_of: :account
+    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
+    
+    if defined? Extface
+      belongs_to :extface_job, class_name: 'Extface::Job'
+    end
     
     accepts_nested_attributes_for :charges, :modifiers, :payments
     
+    delegate :payment_model, to: :origin, prefix: :origin, allow_nil: true
+    
+    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 ) }
+    
     before_validation :update_sumaries
     
+    before_save on: :create do
+      self.number = "#{billable.id}:#{billable.billing_accounts.count}"
+      self.name = "B:#{number}" if name.nil?
+    end
+    before_save :perform_autofin, if: :becomes_paid?
+    
     validates_numericality_of :total, greater_than_or_equal_to: 0
+    validates_numericality_of :balance, less_than_or_equal_to: 0
+    validates_presence_of :origin, if: :has_payments?
+    
+    validates_absence_of :payments_of_diff_models?, 
+      :payments_of_diff_fiscalization?, :multiple_cash_payments?, if: :has_payments?
     
     def charge(*args)
       c = charges.new Charge.args(*args)
@@ -29,7 +55,7 @@ module Billing
     end
     
     def pay(*args)
-      p = payments.new Payment.args(*args)
+      p = build_typed_payment Payment.args(*args)
       p if p.save
     end
     
@@ -38,7 +64,28 @@ module Billing
     end
     
     def payment_types
-      billable.try(:billing_payment_types) || billable.try(:payment_types) || []
+      billable.try(:billing_payment_types) || Billing::PaymentType.all
+    end
+    
+    def origins
+      billable.try(:billing_origins) || Billing::Origin.all
+    end
+    
+    def has_payments?
+      payments.any?
+    end
+    
+    def paid?
+      has_payments? && balance.zero?
+    end
+    
+    def build_typed_payment(attributes = {})
+      payments.new(attributes.merge(type: origin.try(:payment_model) || 'Billing::PaymentWithType'))
+    end
+    
+    def fiscalize #TODO test
+      extface_job = origin.fiscal_device.fiscalize(self) if fiscalizable? && origin.try(:fiscal_device)
+      extface_job if save
     end
 
     private
@@ -46,7 +93,8 @@ module Billing
         @modifier_items = ModifierItems.new.tap() do |items|
           modifiers.each do |modifier|
             if charge = modifier.charge
-              items << Charge.new(price: modifier.percent_ratio.nil? ? modifier.fixed_value : (charge.price * modifier.percent_ratio), chargable: 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
@@ -62,5 +110,35 @@ module Billing
         self.total = charges_sum + surcharges_sum - discounts_sum
         self.balance = payments_sum - total
       end
+      
+      def payments_of_diff_models?
+        payments.to_a.group_by(&:type).many?
+      end
+      
+      def payments_of_diff_fiscalization?
+        payments.to_a.group_by(&:fiscal?).many?
+      end
+      
+      def multiple_cash_payments?
+        payments.to_a.select(&:cash?).many?
+      end
+      
+      def becomes_paid?
+        finalized_at.nil? && has_payments? && balance.zero?
+      end
+      
+      def perform_autofin
+        if autofin
+          self.finalized_at = Time.now
+          if defined? Extface
+            self.extface_job = origin.fiscal_device.fiscalize(self) if fiscalizable? && origin.try(:fiscal_device)
+          end
+        end
+        true
+      end
+      
+      def fiscalizable?
+        payments.select(&:fiscal?).any?
+      end
   end
 end

data/app/models/billing/charge.rb

@@ -3,9 +3,24 @@ module Billing
     include AccountItem
     belongs_to :account, 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 :value_cents
+    
+    delegate :paid?, to: :account
+    
+    scope :unpaid, -> { joins(:account).where.not(billing_accounts: { balance_cents: 0}) }
+    scope :paid, -> { joins(:account).where(billing_accounts: { 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
+    end
     
     class << self
       def args(*args)

data/app/models/billing/department.rb

@@ -0,0 +1,5 @@
+module Billing
+  class Department < ActiveRecord::Base
+    belongs_to :tax_group
+  end
+end

data/app/models/billing/modifier.rb

@@ -2,10 +2,12 @@ module Billing
   class Modifier < ActiveRecord::Base
     include AccountItem
     belongs_to :account, inverse_of: :modifiers, validate: true
-    belongs_to :charge
+    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
     
     private
       def percent_or_value

data/app/models/billing/operator.rb

@@ -0,0 +1,4 @@
+module Billing
+  class Operator < ActiveRecord::Base
+  end
+end

data/app/models/billing/origin.rb

@@ -1,4 +1,17 @@
 module Billing
   class Origin < ActiveRecord::Base
+    has_many :accounts, inverse_of: :origin
+    has_many :charges, inverse_of: :origin
+    has_many :payments, through: :accounts
+    if defined? Extface
+      belongs_to :fiscal_device, ->(o) { where( extfaceable_id: o.master_id ) }, class_name: 'Extface::Device'
+    end
+
+    validates_presence_of :name
+    validates :payment_model, inclusion: { in: Payment::PAYMENT_MODELS }
+    
+    def external_payment?
+      payment_model != Payment::PAYMENT_WITH_TYPE
+    end
   end
 end

data/app/models/billing/payment.rb

@@ -1,39 +1,68 @@
 module Billing
   class Payment < ActiveRecord::Base
+    PAYMENT_WITH_TYPE = 'Billing::PaymentWithType'.freeze
+    PAYMENT_EXTERNAL = 'Billing::PaymentExternal'.freeze
+    PAYPAL_EXPRESS = 'Billing::PaypalExpress'.freeze
+    PAYMENT_MODELS = [PAYMENT_WITH_TYPE, PAYMENT_EXTERNAL, PAYPAL_EXPRESS].freeze
+    
     include AccountItem
-    belongs_to :account, inverse_of: :payments, validate: true
     
+    attr_writer :origin
+    attr_accessor :origin_id
     monetize :value_cents
+
+    belongs_to :account, inverse_of: :payments, validate: true
     
-    delegate :billable, to: :account
+    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 }) }
     
-    validates_presence_of :value
+    if defined? Extface
+      belongs_to :extface_job, class_name: 'Extface::Job'
+    end
+    
+    delegate :billable, to: :account
+
+    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).to_money if value.zero?
+      self.value = -account.try(:balance) if value.zero?
     end
     
-    class << self
-      def args(*args)
-        h = { type: 'Billing::PaymentWithType' }
-        case when args.blank? || args.first.kind_of?(Hash) then
-          args.blank? ? h : h.merge(*args)
-        when args.first.kind_of?(String) then
-            #TODO parse
-        else
-          h.merge!(payment_type_id: args.shift.to_param)
-          if args.any? && (args.first.kind_of?(Hash) || args.first.kind_of?(String))
-            h.merge(args(*args))
+    before_validation do
+      account.origin = origin unless account.origin and account.payments.many?
+    end
+    
+    def fiscal?; false; end
+    def cash?; false; end
+    def external?; false; end
+    
+    def origin
+      @origin || origins.find_by_id(@origin_id)
+    end
+    
+    private
+      class << self
+        def args(*args)
+          h = {}
+          case when args.blank? || args.first.kind_of?(Hash) then
+            args.blank? ? h : h.merge(*args)
+          when args.first.kind_of?(String) then
+              #TODO parse
           else
-            if args.blank?
-              h
+            h.merge!(payment_type_id: args.shift.to_param)
+            if args.any? && (args.first.kind_of?(Hash) || args.first.kind_of?(String))
+              h.merge(args(*args))
             else
-              h.merge!( value: args.shift.to_money )
-              args.any? ? h.merge(*args) : h
+              if args.blank?
+                h
+              else
+                h.merge!( value: args.shift.to_money )
+                args.any? ? h.merge(*args) : h
+              end
             end
           end
         end
       end
-    end
   end
 end

data/app/models/billing/payment_external.rb

@@ -0,0 +1,8 @@
+module Billing
+  class PaymentExternal < Payment
+    validates_presence_of :external_token
+    
+    def external?; true; end
+    
+  end
+end

data/app/models/billing/payment_type.rb

@@ -1,6 +1,8 @@
 module Billing
   class PaymentType < ActiveRecord::Base
-    has_many :payments
+    has_many :payments, inverse_of: :payment_type
+    has_many :payment_type_fiscal_driver_mappings, inverse_of: :payment_type
+
     validates_presence_of :name
   end
 end

data/app/models/billing/payment_type_fiscal_driver_mapping.rb

@@ -0,0 +1,7 @@
+module Billing
+  class PaymentTypeFiscalDriverMapping < ActiveRecord::Base
+    self.table_name = "billing_pt_fp_mappings"
+    belongs_to :payment_type, inverse_of: :payment_type_fiscal_driver_mappings
+    belongs_to :extface_driver, class_name: 'Extface::Driver'
+  end
+end

data/app/models/billing/payment_with_type.rb

@@ -1,14 +1,30 @@
 module Billing
   class PaymentWithType < Payment
     belongs_to :payment_type, inverse_of: :payments
-    delegate :payment_types, to: :account
     
     validates_presence_of :payment_type
     validates :payment_type, inclusion: { in: :payment_types }
     
     after_initialize on: :create do
-      self.payment_type = billable.try(:default_payment_type) unless payment_type
+      self.payment_type = default_payment_type unless payment_type
     end
     
+    def fiscal?
+      payment_type.fiscal
+    end
+    
+    def cash?
+      payment_type.cash
+    end
+    
+    private
+      def default_payment_type
+        if pt = billable.try(:default_payment_type)
+          pt
+        else
+          account.payment_types.try(:first) unless account.payment_types.many?
+        end
+      end
+    
   end
 end

data/app/models/billing/paypal_express.rb

@@ -0,0 +1,7 @@
+module Billing
+  class PaypalExpress < Payment
+    
+    def paypal_express?; true; end
+    
+  end
+end

data/app/models/billing/report.rb

@@ -0,0 +1,66 @@
+module Billing
+  class Report < ActiveRecord::Base
+    FISCAL_X_REPORT = 'x_report'.freeze
+    FISCAL_Z_REPORT = 'z_report'.freeze
+    FISCAL_PERIOD_REPORT = 'period_report'.freeze
+    F_OPERATIONS = [FISCAL_X_REPORT, FISCAL_Z_REPORT, FISCAL_PERIOD_REPORT].freeze
+      
+    has_paper_trail class_name: 'Billing::Version'
+    belongs_to :origin, inverse_of: :reports
+    has_many :accounts, inverse_of: :report, autosave: true
+    belongs_to :extface_job, class_name: 'Extface::Job'
+    has_many :payments, through: :accounts
+
+    monetize :payments_sum_cents
+    monetize :payments_cash_cents
+    monetize :payments_fiscal_cents
+    
+    validates_presence_of :origin
+    validates_absence_of :partially_paid_accounts?
+    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_create :update_summary
+    
+    
+    def fiscalization
+      if origin.fiscal_device.present?
+        perform_fiscal_job
+        save
+      end
+    end
+    
+    private
+    
+      def fiscal_period_report?
+        f_operation == FISCAL_PERIOD_REPORT
+      end
+      
+      def set_report_to_accounts
+        self.accounts << origin.accounts.select(&:paid?) 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)
+        perform_fiscal_job
+      end
+      
+      def perform_fiscal_job
+        case f_operation
+        when FISCAL_Z_REPORT then
+          self.extface_job = origin.fiscal_device.driver.z_report_session
+        when FISCAL_X_REPORT then
+          self.extface_job = origin.fiscal_device.driver.x_report_session
+        when FISCAL_PERIOD_REPORT then
+          p "period"
+        end
+      end
+      
+      def partially_paid_accounts?
+        accounts.partially_paid.any?
+      end
+  end
+end