billing 0.0.4 → 0.0.5a

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f6a8b7a29cfa69d401eb731dbb4dcc67a9016d5e
-  data.tar.gz: 4ef3454d28c7e0b42f9bb55108131baad90d7ef4
+  metadata.gz: 2fa427a04690d7629d0a08954514d57f5be1d9b7
+  data.tar.gz: dac8e6fb5fcbf41022da2c731a99ad83d5ddab8c
 SHA512:
-  metadata.gz: 1c2f6ff8668e4f23630342d787596721706900dc4dfe9b2aa5f33552774fa42f6f165912b456ec220d0866fe68f9bb06ceb64ba79bb4c52d3a3f3a5a361d8d5f
-  data.tar.gz: 5e39901f8155e9a73206311bd4bea98417856e366456868579cc2be1ee3717f660c3cb625ac445e9321fee0317ae55fa587dc13d39756bd9c17c14ddae0255e0
+  metadata.gz: 0401503350829e7ed2f468740b26ddbf2214187d3daa393292347c080f90a29eba53a175364b4cda0050eff04f0197b3973a80ba8e35eb28777095c53c625590
+  data.tar.gz: 6ae75a0cd7c7878501c38982837d39ce48c1684f5d1421e1b9fa5f004a2afda73be696f68f6f05bb013a4cc9d0c693089b2472c28dc62850ca7d8d9dea2f66e6

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
@@ -64,11 +64,11 @@ module Billing
     end
     
     def payment_types
-      billable.try(:billing_payment_types) || Billing::PaymentType.all
+      billable.try(:billing_payment_types) #|| Billing::PaymentType.all
     end
     
     def origins
-      billable.try(:billing_origins) || Billing::Origin.all
+      billable.try(:billing_origins) #|| Billing::Origin.all
     end
     
     def has_payments?
@@ -80,34 +80,39 @@ module Billing
     end
     
     def build_typed_payment(attributes = {})
-      payments.new(attributes.merge(type: origin.try(:payment_model) || 'Billing::PaymentWithType'))
+      payment_origin = attributes[:origin] || origins.find_by_id(attributes[:origin_id])
+      payments.new(attributes.merge(type: (payment_origin || 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
+      self.extface_job = origin.fiscal_device.fiscalize(self) if fiscalizable? && origin.try(:fiscal_device)
+      self.extface_job if save
     end
 
     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)
+            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
       
@@ -138,7 +143,8 @@ module Billing
       end
       
       def fiscalizable?
-        payments.select(&:fiscal?)
+        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,10 +1,11 @@
 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'
+      belongs_to :transfer_device, ->(o) { where( extfaceable_id: o.master_id ) }, class_name: 'Extface::Device'
     end
 
     validates_presence_of :name
@@ -13,5 +14,9 @@ module Billing
     def external_payment?
       payment_model != Payment::PAYMENT_WITH_TYPE
     end
+    
+    def room_transfer?
+      payment_model == Payment::ROOM_TRANSFER
+    end
   end
 end

data/app/models/billing/payment.rb

@@ -3,34 +3,31 @@ module Billing
     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
+    ROOM_TRANSFER = 'Billing::RoomTransfer'.freeze
+    PAYMENT_MODELS = [PAYMENT_WITH_TYPE, PAYMENT_EXTERNAL, PAYPAL_EXPRESS, ROOM_TRANSFER].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, allow_nil: true
 
     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 bill && value.zero?
     end
     
     def fiscal?; false; end
@@ -43,7 +40,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

@@ -2,6 +2,8 @@ module Billing
   class PaymentWithType < Payment
     belongs_to :payment_type, inverse_of: :payments
     
+    delegate :fiscal?, :cash?, to: :payment_type, allow_nil: true
+    
     validates_presence_of :payment_type
     validates :payment_type, inclusion: { in: :payment_types }
     
@@ -9,20 +11,12 @@ module Billing
       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?
+          bill.try(:payment_types).try(:first) unless bill.try(:payment_types).try(:many?)
         end
       end
     

data/app/models/billing/report.rb

@@ -3,26 +3,32 @@ module Billing
     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
+    FISCAL_PAYED_RECVD = 'payed_recvd'.freeze
+    F_OPERATIONS = [FISCAL_X_REPORT, FISCAL_Z_REPORT, FISCAL_PERIOD_REPORT, FISCAL_PAYED_RECVD].freeze
       
     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
+    monetize :f_amount_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?
+    validates_inclusion_of :positive_f_period?, in: [true], if: :fiscal_period_report?
+    validates_presence_of :f_amount, if: :fiscal_payed_recvd?
     
-    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 +43,18 @@ module Billing
         f_operation == FISCAL_PERIOD_REPORT
       end
       
-      def set_report_to_accounts
-        self.accounts << origin.accounts.select(&:paid?) if zeroing?
+      def fiscal_payed_recvd?
+        f_operation == FISCAL_PAYED_RECVD
+      end
+      
+      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
       
@@ -55,12 +65,18 @@ module Billing
         when FISCAL_X_REPORT then
           self.extface_job = origin.fiscal_device.driver.x_report_session
         when FISCAL_PERIOD_REPORT then
-          p "period"
+          self.extface_job = origin.fiscal_device.driver.period_report_session(f_period_from, f_period_to, f_detailed)
+        when FISCAL_PAYED_RECVD then
+          self.extface_job = origin.fiscal_device.driver.payed_recv_account(f_amount.to_f)
         end
       end
       
-      def partially_paid_accounts?
-        accounts.partially_paid.any?
+      def partially_paid_bills?
+        bills.partially_paid.any?
+      end
+      
+      def positive_f_period?
+        f_period_from < f_period_to if f_period_from && f_period_to
       end
   end
 end

data/app/models/billing/room_transfer.rb

@@ -0,0 +1,4 @@
+module Billing
+  class RoomTransfer < Payment
+  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