stockor-core 0.2

data/lib/skr/sequential_id.rb

@@ -0,0 +1,23 @@
+module Skr
+    class SequentialId < Skr::Model
+        FUNCTION_NAME="#{Skr::Core.config.table_prefix}next_sequential_id"
+
+        self.primary_key = 'name'
+
+        locked_fields :name, :current_value
+
+        def self.next_for( klass )
+            begin
+                res=ActiveRecord::Base.connection.raw_connection.exec( "select #{FUNCTION_NAME}( $1 )", [ klass.to_s ] )
+                res.getvalue(0,0).to_i
+            ensure
+                res.clear if res
+            end
+        end
+
+        def self.set_next( klass, value )
+            self.connection.raw_connection.exec( "update #{table_name} set current_value = $1 where name = $2", [ value, klass.to_s ] )
+        end
+
+    end
+end

data/lib/skr/sku.rb

@@ -0,0 +1,99 @@
+module Skr
+
+    #### A (S)tock (K)eeping (U)nit (SKU) is the cornerstone of Stockor
+    #
+    # At it's simplest form a SKU tracks a *resource* that the company controlls.
+    # It can be manufactured (by combining other SKUs), purchased, stored, and sold.
+    #
+    # Although SKUs usually refer to physical item, it may also track intangibles
+    # such as "Labor", "Handling", or "Freight"
+    #
+    class Sku < Skr::Model
+
+        has_code_identifier :from=>'description'
+
+        belongs_to :default_vendor,   class_name: 'Skr::Vendor',    export: true
+        belongs_to :gl_asset_account, class_name: 'Skr::GlAccount', export: true
+        belongs_to :default_vendor,   class_name: 'Skr::Vendor',    export: true
+
+        has_many :sku_locs, ->{extending Concerns::Sku::Locations },
+            inverse_of: :sku, dependent: :destroy,
+            export: { writable:true }
+
+        has_many :sku_vendors, ->{ extending Concerns::Sku::Vendors },
+            dependent: :destroy,  inverse_of: :sku,
+            export: { writable: true, allow_destroy: true }
+
+        has_many :uoms, ->{ order(:size); extending(Concerns::Sku::Uoms) },
+            dependent: :destroy, inverse_of: :sku,
+            export: { writable: true, allow_destroy: true }
+
+        validates :uoms,                presence: true, :on => :update
+        validates :description,         presence: true
+        validates :gl_asset_account,    set: true
+        validates :default_vendor,      set: true
+        validates :default_uom_code,    presence: true, :on => :update
+        validate  :ensure_default_uom_exists
+
+        before_validation :set_defaults, :on=>:create
+        after_create  :create_associated_records
+
+        scope :with_vendor_part_code, lambda { | vendor_sku |
+            joins(:sku_vendors).where( SkuVendor.arel_table[:part_code].matches( vendor_sku ) )
+        }, :export=>true
+
+        scope :in_location, lambda { | location_id |
+            joins(:sku_locs).where( SkuLoc.table_name => { location_id: location_id } )
+        }, :export=>true
+
+        scope :with_qty_details, lambda { | *args |
+            compose_query_using_detail_view( view: 'sku_qty_details', join_to: 'sku_id' )
+        }, export: { :join_table=>:details }
+
+        scope :only_back_ordered, lambda{ | *args |
+            with_qty_details.where("details.qty_on_order > details.qty_on_hand")
+        }, export: true
+
+
+        # Rebuilding is sometimes needed for cases where the location's
+        # allocation/on order/reserved counts get out of sync with the
+        # SalesOrder counts.  This forces recalculation of the cached values
+        def rebuild!
+            sku_locs.each(&:rebuild!)
+        end
+
+        private
+
+        # If the default uom code was changed, make sure the UOM
+        # is actually present on the uoms list
+        def ensure_default_uom_exists
+            if default_uom_code_changed? && uoms.default.nil?
+                errors.add( :default_uom_code, "does not exist on UOMs" )
+            end
+        end
+
+        # Setup the associations after create
+        def create_associated_records
+            if sku_locs.empty?
+                self.sku_locs.create({ sku: self, location: Location.default })
+            end
+            true # don't cancel save op
+        end
+
+        # Set the default values for the Sku if they are not present
+        def set_defaults
+            if self.default_vendor.blank? && self.sku_vendors.any?
+                self.default_vendor = self.sku_vendors.at(0).vendor
+            end
+            self.uoms << Uom.ea if self.uoms.empty?
+
+            self.can_backorder      = Core.config.skus_backorder_default if self.can_backorder.nil?
+            self.gl_asset_account ||= GlAccount.default_for(:asset)
+            self.default_uom_code ||= self.uoms.first.code
+
+            true # don't cancel save op
+        end
+
+    end
+
+end # Skr module

data/lib/skr/sku_loc.rb

@@ -0,0 +1,94 @@
+module Skr
+
+    # Next to the {Sku} class, SkuLoc is the second most integral model in Stockor.  It tracks
+    # which Skus are setup in each location and the related quantity information about them
+    #
+    # It is also the model that is linked to by other models that need to refer to a sku's location
+    # such as the lines on {PurchaseOrder}, Quotes, {SalesOrder}, PickTickets, and Invoices
+    class SkuLoc < Skr::Model
+
+        belongs_to :sku,      export: true
+        belongs_to :location, export: true
+
+        has_many :so_lines, inverse_of: :sku_loc,  extend: Concerns::SO::Lines, listen: { qty_change: :update_so_qty }
+        has_many :pt_lines, :inverse_of=>:sku_loc, extend: Concerns::PT::Lines, listen: { save: :update_qty_picking }
+
+        has_many :sku_vendors, :primary_key=>:sku_id, :foreign_key=>:sku_id
+
+        delegate_and_export :location_name, :location_code
+        delegate_and_export :sku_code,      :sku_description
+
+        validates :mac, numericality: true
+        validates :sku, :location, presence: true
+        validates :sku, uniqueness: { scope: :location_id, message: "SKU may not be in the same location twice" }
+
+        export_methods :qty_available
+
+        locked_fields :qty, :mac
+
+        has_additional_events :qty_change
+
+        # @return [BigDecimal] the value of inventory for {Sku} in this {Location}
+        def onhand_mac_value
+            qty*mac
+        end
+
+        # @return [Fixnum] the qty that is not allocated, picking or reserved
+        def qty_available
+            qty - qty_allocated - qty_picking - qty_reserved
+        end
+
+        # Adjust the on hand qty.  Can only be called while qty is unlocked
+        # @example
+        #   sl = SkuLoc.first
+        #   sl.unlock_fields( :qty ) do
+        #     sl.adjust_qty( 10 )
+        #     sl.save!
+        #   end
+        # @param [Fixnum] qty the amount to adjust the onhand qty by
+        # @return [Fixnum] new qty on hand
+        def adjust_qty( qty )
+            self.qty += qty
+        end
+
+        # Rebuilding is sometimes needed for cases where the location's
+        # allocation/on order/reserved counts get out of sync with the
+        # SalesOrder counts.  This forces recalculation of the cached values
+        def rebuild!
+            self.update_attributes({
+                qty_picking: pt_lines.pt_lines.picking_qty,
+                qty_allocated: self.so_lines.open.allocated.eq_qty_allocated
+              })
+        end
+
+        # Allocate the maximum available quantity to {SalesOrder}
+        # that are not currrently allocated
+        def allocate_available_qty!
+            update_so_qty
+            so_lines.unallocated.order(:created_at).each do | sol |
+                sol.sku_loc = self
+                sol.allocate_max_available
+                sol.save
+                break if qty_allocated <= 0
+            end
+        end
+
+        private
+
+        def fire_after_save_events
+            fire_event(:qty_change) if qty_changed?
+        end
+
+        # Caches the qty of skus that are allocated to sales orders in the {#qty_allocated} field
+        def update_so_qty( so_line=nil )
+            self.update_attributes({ qty_allocated: self.so_lines.open.allocated.eq_qty_allocated })
+        end
+
+        def update_qty_picking( pt=nil )
+            update_attributes( :qty_picking=> self.pt_lines.picking.ea_picking_qty )
+        end
+
+    end
+
+
+end # Skr module

data/lib/skr/sku_tran.rb

@@ -0,0 +1,111 @@
+module Skr
+
+    # In Stockor, inventory related transactions are not performed directly on the model(s)
+    #
+    # Instead a SkuTran is created, and it is responsible for adjusting
+    # either the cost or qty of the inventory.  By doing so, all inventory
+    # changes is logged and can be referred to in order to audit
+    # changes.
+    class SkuTran < Skr::Model
+
+        acts_as_uom
+
+        is_immutable
+
+        belongs_to :sku_loc
+        has_one :location, :through => :sku_loc
+
+        belongs_to :origin, :polymorphic=>true
+
+        has_one :gl_transaction, :as=>:source, :inverse_of=>:source
+
+        validates :sku_loc, :set=>true
+        validates :origin_description, :presence=>true
+        validates :prior_mac,          :numericality=>true
+
+        validate  :ensure_cost_and_qty_present
+
+        attr_accessor :credit_gl_account
+        attr_accessor :debit_gl_account
+        attr_accessor :gl_tran_description_text
+
+        after_save  :adjust_sku_loc_values
+        after_save  :create_needed_gl_transaction
+        before_save :calculate_mac
+
+        attr_accessor :allocate_after_save
+
+        # @param sl [SkuLoc] set's the sku loc and also sets {#prior_qty} and {#prior_mac}
+        def sku_loc=(sl)
+            super
+            self.prior_qty = sl.qty
+            self.prior_mac = sl.mac
+        end
+
+        # @return [Fixnum] {#qty} expressed in terms of single UOM
+        def ea_qty
+            self.qty * ( self.uom_size || 1 )
+        end
+
+        # @return [String] a description intended for use by the #{GlTransaction}
+        # def description_for_gl_transaction(gl)
+        #     self.origin_description
+        # end
+
+        private
+
+        # sets {#mac} to the correct amount for the {SkuLoc}.
+        # To calculate the MAC, the {SkuLoc#onhand_mac_value} is added to {#cost}
+        # and then divided by #{SkuLoc#qty} + {#ea_qty}
+        def calculate_mac
+            new_qty = sku_loc.qty + self.ea_qty
+            return true if self.mac.present?
+            if new_qty.zero?
+                self.mac = BigDecimal.new(0)
+            elsif cost
+                self.mac = ( sku_loc.onhand_mac_value + cost ) / new_qty
+            else
+                self.mac = sku_loc.onhand_mac_value
+            end
+            true
+        end
+
+        # If {#cost} is non-zero, then create a {GlTransaction}
+        def create_needed_gl_transaction
+            Skr::Core.logger.debug "Recording SkuTran in GL, mac is: #{self.mac}, cost = #{cost}"
+            return if self.cost.nil? || self.cost.zero?
+            GlTransaction.push_or_save(
+              owner: self, amount: cost,
+              debit: debit_gl_account, credit: credit_gl_account
+            )
+        end
+
+        # Adjusts {SkuLoc#qty} by {#ea_qty}
+        def adjust_sku_loc_values
+            sl = self.sku_loc
+            Skr::Core.logger.debug "Adj +#{ea_qty} Sku #{sl.sku.code} location #{location.code} " +
+                                   "from MAC: #{sl.mac} to #{self.mac}, qty: #{sl.qty} += #{ea_qty} #{combined_uom}"
+            sl.unlock_fields( :qty, :mac ) do
+                sl.mac = self.mac unless self.mac.nan? or self.mac.zero?
+                sl.adjust_qty( ea_qty )
+                sl.save!
+            end
+            sl.reload
+            sl.allocate_available_qty! if self.allocate_after_save
+
+            Skr::Core.logger.debug "After Adj Qty #{sl.qty}"
+        end
+
+        def ensure_cost_and_qty_present
+            if ea_qty.zero?
+                errors.add( :base, "Transaction has no effect, must change inventory onhand value")
+            end
+            if cost.present? && cost.nonzero? && debit_gl_account.nil?
+                errors.add( :debit_gl_account, "was not specified even though we need to adjust the GL by #{cost}")
+            end
+        end
+
+    end
+
+
+end # Skr module

data/lib/skr/sku_vendor.rb

@@ -0,0 +1,26 @@
+module Skr
+
+    class SkuVendor < Skr::Model
+
+        acts_as_uom
+
+        belongs_to :sku,    inverse_of:  :sku_vendors, export: true
+        belongs_to :vendor, inverse_of:  :sku_vendors, export: true
+        has_many :sku_locs, primary_key: :sku_id,      export: true
+
+        delegate_and_export :vendor_code, :vendor_name
+        delegate_and_export :sku_code, :sku_description
+
+        validates :list_price, :cost, :uom_size, :numericality=>true, :presence=>true
+        validates :uom_code, :part_code, :presence=>true
+        validates :sku, :uniqueness=>{ scope: :part_code }
+
+        scope :in_location, lambda { | location |
+            location_id = location.is_a?(Numeric) ? location : location.id
+            includes(:sku_locs).references(:sku_locs).where(['sku_locs.location_id=?',location_id])
+        }, :export=>true
+
+
+    end
+
+end # Skr module

data/lib/skr/so_line.rb

@@ -0,0 +1,159 @@
+module Skr
+
+    class SoLine < Skr::Model
+
+        acts_as_uom
+        is_sku_loc_line parent: 'sales_order'
+
+        belongs_to :sales_order
+        belongs_to :sku_loc, export: true
+        has_one :sku, :through => :sku_loc, export: true
+        has_one :location, :through => :sales_order
+        has_many :pt_lines,  :before_add=>:setup_new_pt_line, :inverse_of=>:so_line,
+                 extend: Concerns::PT::Lines, :listen=>{save:'update_qty_picking'}
+
+        # has_many :inv_lines, :before_add=>:setup_new_inv_line, :inverse_of=>:so_line
+
+        validates :sales_order, :sku_loc,  set: true
+
+        validates :price, :qty, :numericality=>true
+        validates :qty_allocated, :numericality=>{ :greater_than_or_equal_to=>0 }
+        validate  :ensure_allocation_is_correct
+        validate  :ensure_so_is_open, on: :create
+
+        has_additional_events :qty_change
+
+        before_validation   :set_defaults_from_associations
+        before_create  :allocate_max_available
+        before_destroy :ensure_deleteable
+
+        scope :open, ->{
+            joins(:sales_order).merge(SalesOrder.open).where( arel_table[:qty].gt( arel_table[:qty_invoiced] ) )
+        }
+        scope :allocated,   ->{ where( arel_table[:qty_allocated].gt( 0 ) ) }
+        scope :unallocated, ->{
+            t = table_name; where( "#{t}.qty_allocated < #{t}.qty - #{t}.qty_invoiced - #{t}.qty_canceled" )
+        }
+        scope :unshipped, lambda {|unused=nil|
+            t = table_name; where( "#{t}.qty > #{t}.qty_invoiced + #{t}.qty_canceled" )
+        }
+        scope :pickable,    ->{ where( arel_table[:qty_allocated].gt( arel_table[:qty_picking] ) ) }
+
+        def location=(location)
+            self.cancel!
+            self.sku_loc = self.sku.sku_locs.find_or_create_for( location )
+            self.allocate_max_available
+            self.save!
+            self
+        end
+
+        # allocate the maximum available qty to the line
+        def allocate_max_available
+            self.qty_allocated = [ 0, [ sku_loc.qty_available+qty_allocated, qty ].min ].max if self.sku.does_track_inventory?
+            self
+        end
+
+        # A line is fully allocated if the qty_allocated is less than the qty ordered - the qty invoiced - the qty canceled
+        # @return [Boolean]
+        def is_fully_allocated?
+            self.qty_allocated >= qty - qty_invoiced - qty_canceled
+        end
+
+        # The pickable qty is the qty allocated - the qty already on pick tickets
+        # @return [Fixnum]
+        def pickable_qty
+            qty_allocated - qty_picking
+        end
+
+        def cancel!
+            self.update_attributes :qty_allocated => 0, :qty_picking=> 0
+            pt_lines.picking.each{ |ptl| ptl.cancel! }
+        end
+
+        private
+
+        def update_qty_shipped
+            inv_qty = self.inv_lines.sum(:qty)
+            update_attributes( :qty_invoiced=> inv_qty, :qty_allocated => [ qty_allocated - inv_qty, 0 ].max )
+        end
+        def update_qty_picking( pt=nil )
+            update_attributes( :qty_picking=> pt_lines.ea_picking_qty/uom_size )
+        end
+
+
+        def fire_after_save_events
+            %w{ allocated picking invoiced canceled }.each do | event |
+                if changes[ "qty_#{event}" ]
+                    fire_event( :qty_change )
+                    break
+                end
+            end
+            super
+        end
+
+        def set_defaults_from_associations
+            self.uom         = sku.uoms.default if self.uom_code.blank?
+            self.description = sku.description if self.description.blank?
+            self.sku_code    = sku.code        if self.sku_code.blank?
+            if !price && sales_order && sales_order.customer && sku_loc && uom.present?
+                self.price = Core.config.pricing_provider.price(sku_loc:sku_loc, customer:sales_order.customer, uom:uom, qty:qty)
+            end
+            true
+        end
+
+        def setup_new_inv_line( line )
+            line.qty = self.sku.is_other_charge? ? self.qty : self.qty_allocated
+            setup_new_line(line)
+        end
+        def setup_new_pt_line( line )
+            line.qty = self.sku.is_other_charge? ? self.qty : self.pickable_qty
+            setup_new_line(line)
+        end
+
+        def setup_new_line(line)
+            line.price    = self.price
+            line.sku_loc  = self.sku_loc
+            line.uom      = self.uom
+            true
+        end
+
+        def ensure_allocation_is_correct
+            return true unless qty_allocated_changed?
+            diff = qty_allocated - qty_allocated_was
+            if qty_allocated > qty
+                errors.add(:qty_allocated, "must be less than qty ordered (#{qty})")
+            end
+            if diff > 0 && sku_loc && diff > sku_loc.qty_available
+                errors.add(:qty_allocated, "new allocation (#{qty_allocated}) - old allocation (#{qty_allocated_was}) can't be more than qty available (#{ sku_loc.qty_available })")
+                return false
+            end
+            true
+        end
+
+
+        def ensure_so_is_open
+            unless self.sales_order.open?
+                errors.add(:base,"Cannot add item #{self.sku_code} to non-open Sales Order")
+                return false
+            end
+            true
+        end
+
+        def ensure_deleteable
+            if qty_allocated > 0
+                errors.add(:base,'Cannot delete line when allocated')
+                return false
+            end
+            if qty_invoiced > 0
+                errors.add(:base,"Cannot delete line after it's shipped")
+                return false
+            end
+            true
+        end
+
+
+
+    end
+
+
+end # Skr module