stockor 0.1.5

data/lib/skr/models/business_entity.rb

@@ -0,0 +1,29 @@
+module Skr
+
+    module BusinessEntity
+
+        extend ActiveSupport::Concern
+
+        included do
+            has_random_hash_code
+            has_code_identifier from: 'name'
+
+            belongs_to :billing_address,  class_name: 'Skr::Address',     export: { writable: true }
+            belongs_to :shipping_address, class_name: 'Skr::Address',     export: { writable: true }
+            belongs_to :terms,            class_name: 'Skr::PaymentTerm', export: { writable: true }
+
+            delegate_and_export :terms_code, :terms_description
+
+            validates :name,  presence: true
+            validates :terms, :billing_address, :shipping_address, set: true
+
+            before_validation :set_defaults, :on=>:create
+        end
+
+        def set_defaults
+            self.terms ||= PaymentTerm.find_by_code(Skr.config.customer_terms_code)
+        end
+
+    end
+
+end

data/lib/skr/models/customer.rb

@@ -0,0 +1,35 @@
+module Skr
+
+    # Customers are Companies (or individuals) that purchase {Sku}s.
+    # They have both a billing and shipping address,
+    # a gl account that payments should be applied against, and a payment term.
+    #
+    class Customer < Skr::Model
+
+        # Common code shared with {Vendor}
+        include BusinessEntity
+
+        belongs_to :gl_receivables_account, class_name: 'Skr::GlAccount', export: true
+
+        has_many :sales_orders, inverse_of: :customer
+        has_many :invoices,     inverse_of: :customer, listen: { save: :update_balance! }
+
+        delegate_and_export :gl_receivables_account_number
+
+        validates :gl_receivables_account, set: true
+
+        # Updates the amount the customer owes, which is the sum of the amount unpaid on open invoices
+        def update_balance!(*)
+            update_attributes open_balance: invoices.open_for_customer(self)
+                                                    .with_details.sum('details.total')
+        end
+
+      private
+
+        def set_defaults
+            super
+            self.gl_receivables_account ||= GlAccount.default_for( :ar )
+        end
+    end
+
+end # Skr module

data/lib/skr/models/gl_account.rb

@@ -0,0 +1,56 @@
+module Skr
+
+    # A GlAccount *(short for General Ledger Account)* is used
+    # to define each class of items for
+    # which money or the equivalent is spent or received.
+    class GlAccount < Skr::Model
+
+        # @private
+        DEFAULT_ACCOUNTS = {}
+
+        is_immutable except: [:name, :is_active]
+
+        validates :name, :description, :presence => true
+
+        # @!attribute description
+        #   A short description of the GL Account
+
+        # A future improvement would be to allow arbitrary account masks.  For now, keep it simple
+        # with mandatory 4 characters + 2 char branch code
+        validates :number, :presence => true, :numericality=>true, :length=>{ :is=>4 }
+
+        # @return [GlAccount] the default account for the key from {Skr::Core::Configuration.default_gl_accounts}
+        def self.default_for( lookup )
+            number = Skr.config.default_gl_accounts[ lookup ]
+            raise RuntimeError.new("Unkown GL default account lookup code: {lookup}") unless number
+            DEFAULT_ACCOUNTS[ lookup ] ||= GlAccount.find_by_number( number )
+        end
+
+        # @return [String] the account number combined with location branch code
+        def number_for_location( location )
+            self.number + location.gl_branch_code
+        end
+
+        # @return [String] the account number combined with the default branch code
+        def default_number
+            self.number + Skr.config.default_branch_code
+        end
+
+        # @return [BigDecimal] The balance for the current period
+        def trial_balance
+            balance_for( GlPeriod.current )
+        end
+
+        # @return [String] the account number suitable for querying all branches
+        def account_mask
+            number + '%'
+        end
+
+        # @return [BigDecimal] the balance for a given period
+        def balance_for( period, mask = self.account_mask )
+            GlPosting.matching( period, account_mask ).sum(:amount)
+        end
+
+    end
+
+end

data/lib/skr/models/gl_manual_entry.rb

@@ -0,0 +1,31 @@
+module Skr
+
+    # Records a manual entry into the General Leger.
+    # Most GL entries are triggered by system events such as an Inventory Receipt, or Invoice payment.
+    # A manual entry differs in that it's performed, well *Manually*.
+    # It's usually used to balance ledger accounts or as part of closing an accounting period.
+    class GlManualEntry < Skr::Model
+
+        has_visible_id
+
+        is_immutable
+
+        has_one :gl_transaction, :as=>:source,
+                inverse_of: :source, export: { writable: true }
+
+        validates :gl_transaction, presence: true
+
+        before_create :copy_notes_to_transaction
+
+        def gl_transaction=( transaction )
+            super
+            copy_notes_to_transaction
+        end
+        private
+
+        def copy_notes_to_transaction
+            self.gl_transaction.description = self.notes[0..100]
+        end
+
+    end
+end

data/lib/skr/models/gl_period.rb

@@ -0,0 +1,13 @@
+module Skr
+
+    class GlPeriod < Skr::Model
+
+        is_immutable
+
+        def self.current
+            attr = { year: Time.now.year, period: Time.now.month }
+            GlPeriod.where( attr ).first || GlPeriod.create( attr )
+        end
+    end
+
+end

data/lib/skr/models/gl_posting.rb

@@ -0,0 +1,54 @@
+module Skr
+    class GlPosting < Skr::Model
+
+        is_immutable
+
+        belongs_to   :gl_transaction
+
+        before_validation  :cache_related_attributes
+
+        validates :gl_transaction,    set: true
+        validates :account_number, numericality: true, length: { :is=>6 }
+        validates :amount,  numericality: true, presence: true
+        validate  :ensure_accounting_validity, on: :create
+
+        scope :applying_to_period, ->(period){ where( '(period <= :period and year = :year) or (year < :year)',
+                                                      { period: period.period, year: period.year } ) }
+        scope :matching, ->(period, account_mask){
+            applying_to_period( period ).where('account_number like ?', account_mask )
+        }
+
+        def account=(acct)
+            @account = acct
+            assign_account_number
+        end
+
+        def location=(location)
+            @location = location
+            assign_account_number
+        end
+
+        private
+
+        def assign_account_number
+            self.account_number = @account.number_for_location(@location) if @account && @location
+        end
+
+        def ensure_accounting_validity
+            unless self.gl_transaction.new_record? #postings_create_ok?
+                self.errors.add( :gl_transaction, "does not accept new postings" )
+            end
+            if @account && ! @account.is_active?
+                self.errors.add(:account, "is not active")
+            end
+
+        end
+
+        def cache_related_attributes
+            assign_account_number
+            self.year   = gl_transaction.period.year
+            self.period = gl_transaction.period.period
+        end
+
+    end
+end

data/lib/skr/models/gl_transaction.rb

@@ -0,0 +1,175 @@
+
+module Skr
+
+    # A transaction is a record of a business event that has financial consequences.
+    # It consists of an at least one credit and at least one debit
+    # Transactions can be nested, with each level compacting all the entries that were made on it
+    #
+    #     require 'skr/core'
+    #     customer = Customer.find_by_code "MONEYBAGS"
+    #     GlTransaction.record( source: invoice, description: "Invoice Example" ) do | transaction |
+    #       transaction.location = Location.default # <- could also specify in record's options
+    #       Sku.where( code: ['HAT','STRING'] ).each do | sku |
+    #           transaction.add_posting( amount: sku.default_price,
+    #                                     debit:  sku.gl_asset_account,
+    #                                    credit: customer.gl_receivables_account )
+    #       end
+    #     end
+    #
+    class GlTransaction < Skr::Model
+
+        is_immutable
+
+        # A Transaction must refer to another record, such as Invoice, Inventory Adjustment, or a Manual Posting.
+        belongs_to :source, :polymorphic=>true
+
+        # Each transaction belongs to an accounting period
+        belongs_to :period, :class_name=>'Skr::GlPeriod', export: true
+
+        has_many :credits, ->{ where({ is_debit: false }) }, class_name: 'Skr::GlPosting',
+                 extend: Concerns::GlTran::Postings,
+                 inverse_of: :gl_transaction, export: { writable: true }
+
+        # Must equal credits, checked by the {#ensure_postings_correct} validation
+        has_many :debits, ->{  where({ is_debit: true }) }, class_name: 'Skr::GlPosting',
+                 extend: Concerns::GlTran::Postings,
+                 inverse_of: :gl_transaction, export: { writable: true }
+
+        before_validation :set_defaults
+        validate  :ensure_postings_correct
+        validates :source, :period,  :set=>true
+        validates :description,      :presence=>true
+
+
+        # Add a debit/credit pair to the transaction with amount
+        # @param amount [BigDecimal] the amount to apply to each posting
+        # @param debit [GlAccount]
+        # @param credit [GlAccount]
+        def add_posting( amount: nil, debit: nil, credit: nil )
+            Skr::Core.logger.debug "GlTransaction add_posting #{debit} : #{credit}"
+            self.credits.build( location: @location, is_debit: false,
+              account: credit, amount: amount )
+            self.debits.build(  location: @location, is_debit: true,
+              account: debit,  amount: amount * -1 )
+        end
+
+        # Passes the location onto the postings.
+        # @param location [Location]
+        def location=(location)
+            @location = location
+            each_posting do | posting |
+                posting.location = location
+            end
+        end
+
+        # @yield [GlPosting] each posting associated with the Transaction
+        def each_posting
+            self.credits.each{ |posting| yield posting }
+            self.debits.each{ |posting| yield posting }
+        end
+
+        # @return [GlTransaction] the current transaction that's in progress
+        def self.current
+            glt = Thread.current[:gl_transaction]
+            glt ? glt.last : nil
+        end
+
+        # Start a new nested GlTransaction
+        # When a transaction is created, it can have
+        # @return [GlTransaction] new transaction
+        # @yield  [GlTransaction] new transaction
+        def self.record( attributes={} )
+            Thread.current[:gl_transaction] ||= []
+            glt = GlTransaction.new( attributes )
+            Thread.current[:gl_transaction].push( glt )
+            Skr::Core.logger.debug "B4 GlTransaction"
+            results = yield glt
+            Thread.current[:gl_transaction].pop
+            if results
+                if results.is_a?(Hash) && results.has_key?(:attributes)
+                    glt.assign_attributes( results[:attributes] )
+                end
+                glt._save_recorded
+                Skr::Core.logger.debug "AF GlTransaction new=#{glt.new_record?} #{glt.errors.full_messages}"
+            end
+            return glt
+        end
+
+        # @param owner [Skr::Model]
+        # @param amount [BigDecimal]
+        # @param debit  [GlAccount]
+        # @param credit  [GlAccount]
+        # @param options  [Hash] options to pass to the [GlTransaction] if one is created
+        def self.push_or_save( owner: nil, amount: nil, debit:nil, credit:nil, options:{} )
+            if glt = self.current # we push
+                glt.add_posting( amount: amount, debit: debit, credit: credit )
+            else
+                options.merge!({
+                    source: owner,
+                    location: options[:location] || owner.location
+                })
+                glt = GlTransaction.new( options )
+                glt.add_posting( amount: amount, debit: debit, credit: credit )
+                glt.save
+            end
+            glt
+        end
+
+        # @private
+        def _save_recorded
+            compact( 'debits'  )
+            compact( 'credits' )
+            self.save if self.credits.any? || self.debits.any?
+            self
+        end
+
+        private
+
+        def compact( assoc_name )
+            accounts = self.send( assoc_name ).to_a
+            self.send( assoc_name + "=", [] )
+            account_numbers = accounts.group_by{ |posting| posting.account_number }
+            account_numbers.each do | number, matching |
+                amount = matching.sum(&:amount)
+                self.send( assoc_name ).build({
+                    account_number: number,
+                    is_debit: ( assoc_name == "debits" ),
+                    amount: amount,
+                })
+            end
+        end
+
+        def ensure_postings_correct
+            if debits.total !=  ( -1 * credits.total )
+                self.errors.add(:credits, "must equal debits")
+                self.errors.add(:debits, "must equal credits")
+                return false
+            end
+            true
+        end
+
+        def set_defaults
+            self.period ||= GlPeriod.current
+        end
+
+        # def ensure_postings_exist
+        #     if self.new_record? and self.postings.empty?
+        #         2.times { self.postings.build }
+        #     end
+        # end
+
+    end
+end
+
+__END__
+
+# export_join_tables :details
+# export_scope :with_details_for, lambda { | acct |
+#     acct = acct.gsub(/\D/,'') + '%'
+#     cs = "case when details.debit_account_number like '#{acct}' then details.debit_amount " +
+#          "when details.credit_account_number like '#{acct}' then details.credit_amount else 0 end"
+#     window = "#{cs} as amount, sum(#{cs}) over (order by created_at) as balance"
+#     joins('join gl_transaction_details as details on details.gl_transaction_id = gl_transactions.id')
+#         .select("gl_transactions.*, details.*, #{window}")
+#         .where("debit_account_number like :acct or credit_account_number like :acct", acct: acct)
+# }

data/lib/skr/models/ia_line.rb

@@ -0,0 +1,129 @@
+module Skr
+
+    # An Inventory Adjustment Line.
+    # Each model contains the {SkuLoc}, cost, UOM, and qty for a {Sku} to adjust
+    #
+    # An adjustment starts out in the "pending" state, then when it moves to the "applied"
+    # state, each line creates an {SkuTran} record that adjusts the inventory in or out.
+    class IaLine < Skr::Model
+
+        acts_as_uom
+
+        belongs_to :inventory_adjustment
+        belongs_to :sku_loc, export: true
+        has_one :sku, :through => :sku_loc, export: true
+
+        has_one :sku_tran, :as=>:origin
+        scope :unapplied, lambda { includes(:sku_tran).references(:sku_tran).where( SkuTran.table_name+'.id is null' ) }
+
+        export_methods :sku_loc_qty, :sku_loc_mac, :optional=>false
+
+        validates :sku_loc, set: true
+        validates :qty,     numericality: true
+        validates :uom_code, :uom_size, presence: true
+        validate  :ensure_cost_set_properly
+
+        before_save    :set_cost_from_sku_loc
+        before_destroy :ensure_adjustment_isnt_applied
+        before_update  :ensure_adjustment_isnt_applied
+        delegate_and_export :sku_code, :sku_description
+
+        has_locks :adjusting
+
+        # @return [Fixnum] The qty available on the location, expressed in terms of the UOM
+        def sku_loc_qty
+            ( self.uom_size && self.sku_loc ) ? BigDecimal.new( self.sku_loc.qty ) / self.uom_size : 0
+        end
+
+        # @return [BigDecimal] the current moving average cost (mac) on the location, expressed in terms of the UOM
+        def sku_loc_mac
+            self.sku_loc ? ( self.sku_loc.mac * self.uom_size ) : 0
+        end
+
+        # @return [Boolean] has the line been applied
+        def is_applied?
+            sku_tran.present?
+        end
+
+        # @return [Boolean] is the qty negative?
+        def is_removing_qty?
+            qty && qty <=0
+        end
+
+        # The qty for the line expressed in terms of the single UOM
+        def ea_qty
+            self.uom_size * self.qty
+        end
+
+        # @return [BigDecimal] the total value of the line
+        def total
+            self.ledger_cost * self.qty
+        end
+        #alias_method :ledger_value, :total
+
+        # @return [BigDecimal] either the current MAC for the sku's location or the cost that was manually set
+        def ledger_cost
+            if cost_was_set? || is_applied?
+                self.cost
+            else
+                self.sku_loc_mac
+            end
+        end
+
+        # copies the cost from the sku_loc to the {#cost} field
+        def set_cost_from_sku_loc
+            if ! cost_was_set?
+                self.cost = self.sku_loc_mac
+            end
+            true
+        end
+
+        # Perform the adjustment.  Requires adjusting to be unlocked and {#is_applied?} must be false
+        #
+        # It creates a {SkuTran} to adjust the inventory, and allocates available qty to the {SoLine}
+        def adjust_qty!
+            if ! is_adjusting_unlocked? || is_applied?
+                raise "Unable to apply line, either not approved or previously applied"
+            end
+            set_cost_from_sku_loc
+            Core.logger.debug( "Adjusting #{self.qty} #{combined_uom} of #{sku_code} into stock")
+            self.build_sku_tran({
+                :origin=>self, :qty => self.qty, :sku_loc=>self.sku_loc,
+                origin_description: "IA #{self.inventory_adjustment.visible_id}:#{self.sku.code}",
+                cost: total,  uom: self.uom,
+                allocate_after_save: true,
+                debit_gl_account:  self.inventory_adjustment.reason.gl_account,
+                credit_gl_account: self.sku.gl_asset_account
+            })
+            self.sku_tran.save unless self.new_record?
+            true
+        end
+
+        private
+
+
+        # Cost cannot be set if the qty is negative
+        def ensure_cost_set_properly
+            if cost_was_set? && is_removing_qty?
+                errors.add(:cost,'cannot be set if removing qty')
+                return false
+            end
+            true
+        end
+
+        def ensure_adjustment_isnt_applied
+            if inventory_adjustment.applied?
+                errors.add(:base,'cannot be modified after adjustment is approved and applied')
+                return false
+            else
+                return true
+            end
+        end
+
+
+
+
+    end
+
+
+end # Skr module

data/lib/skr/models/ia_reason.rb

@@ -0,0 +1,16 @@
+module Skr
+
+    class IaReason < Skr::Model
+
+        has_code_identifier
+
+        belongs_to :gl_account, export: true
+
+        delegate_and_export :gl_account_number, :gl_account_name
+
+        validates :gl_account, set: true
+
+    end
+
+
+end # Skr module

data/lib/skr/models/inv_line.rb

@@ -0,0 +1,90 @@
+module Skr
+
+    class InvLine < Skr::Model
+
+        acts_as_uom
+        is_immutable
+        is_sku_loc_line parent: "invoice"
+
+        locked_fields :qty, :sku_loc_id, :so_line
+        belongs_to :invoice
+
+        belongs_to :so_line, export: true
+        belongs_to :pt_line, :inverse_of=>:inv_line, export: true
+        belongs_to :sku_loc, export: true
+
+        has_one :sku, :through => :sku_loc, export: true
+        has_one :location, :through => :sku_loc
+        has_one :sku_tran, :as=>:origin
+
+        validates :sku_loc,  set: true
+
+        validates :price, :qty, :numericality=>true
+        validates :uom_code, :sku_code, :description, :uom_size, :presence=>true
+
+        before_validation :set_defaults
+        before_save :adjust_inventory
+
+        scope :with_details, lambda { |should_use=true |
+            compose_query_using_detail_view( view: 'inv_details', join_to: 'inv_line_id' ) if should_use
+        }, export: true
+
+        scope :summarize_by, lambda { | values |
+            select( "sum(inv_lines.qty) as qty, count(*) as num_sales, sum(inv_lines.price) as price, avg(inv_lines.price) as avg_price, s.code as sku_code, s.description, s.id as sku_id, 1 as uom_size, 'EA' as uom_code")
+            .joins("join sku_locs sl on sl.id = inv_lines.sku_loc_id join skus s on s.id = sl.sku_id")
+            .where(["inv_lines.created_at between ? and ?",values['from'], values['to'] ])
+            .group('s.code,s.description, s.id')
+        }, export: true
+
+
+        private
+
+        def set_defaults
+#           puts "set_defaults #{self}"
+            line = [ self.pt_line, self.so_line ].detect{ |l| ! l.blank? }
+            if line
+                self.uom         = line.uom if self.uom.blank?
+                self.sku_code    ||= line.sku_code
+                self.description ||= line.description
+                self.sku_loc     ||= line.sku_loc
+                self.qty         ||= line.qty
+                self.so_line     ||= line.so_line
+            elsif sku
+                self.uom           = sku.uoms.default if self.uom_code.blank?
+                self.sku_code    ||= sku.code
+                self.description ||= sku.description
+                self.sku_loc_id  ||= sku.sku_locs.for_location( self.invoice.location ).id if self.invoice && self.invoice.location
+            end
+            if !price && invoice && invoice.customer && sku_loc && uom.present?
+                self.price = Skr.config.pricing_provider.price(
+                  sku_loc:sku_loc,  customer:invoice.customer,
+                  uom:uom, qty: qty )
+            end
+            true
+        end
+
+        def adjust_inventory
+            debit  = self.sku.gl_asset_account
+            credit = self.invoice.customer.gl_receivables_account
+            if self.sku.does_track_inventory?
+                self.build_sku_tran({
+                    origin: self, qty: self.qty*-1, sku_loc: self.sku_loc, uom: self.uom,
+                    mac: 0, cost: self.extended_price,
+                    origin_description: "INV #{self.invoice.visible_id}:#{self.sku.code}",
+                    debit_gl_account:  debit, credit_gl_account: credit
+                })
+            else
+                GlTransaction.push_or_save(
+                  owner: self, amount: self.total,
+                  debit: debit, credit: credit
+                )
+            end
+            true
+        end
+
+
+
+    end
+
+
+end # Skr module

data/lib/skr/models/inventory_adjustment.rb

@@ -0,0 +1,60 @@
+module Skr
+
+    class InventoryAdjustment < Skr::Model
+
+        has_visible_id
+        has_gl_transaction if: :should_apply_gl?
+
+        has_one :gl_transaction, :as=>:source, :inverse_of=>:source
+
+        belongs_to :location, export: true
+        belongs_to :reason, :class_name=>'Skr::IaReason', export: true
+
+        has_many :lines, :class_name=>'Skr::IaLine', :inverse_of=>:inventory_adjustment, export: { writable:true }
+
+        validates :reason, :location, :set=>true
+        validate :ensure_state_is_savable
+        validates_associated :lines
+
+        delegate_and_export :location_code
+        delegate_and_export :reason_code
+
+        state_machine do
+            state :pending , :initial=>true
+            state :applied
+            event :mark_applied do
+                transitions from: :pending, to: :applied
+                before :apply_adjustment
+            end
+        end
+
+        private
+
+        def should_apply_gl?
+            state_event == :mark_applied
+        end
+
+        def attributes_for_gl_transaction
+            { source: self, location: location,
+             description: "IA #{self.visible_id}" }
+        end
+
+        def ensure_state_is_savable
+            if applied? && state_was == 'applied'
+                errors.add('base' , "Cannot update record once it's approved and applied")
+                return false
+            end
+        end
+
+        def apply_adjustment
+            self.lines.each do | line |
+                next if line.is_applied?
+                line.unlock_adjusting{ line.adjust_qty! }
+            end
+            true
+        end
+
+    end
+
+
+end # Skr module