stockor 0.1.5

data/lib/skr/models/sales_order.rb

@@ -0,0 +1,159 @@
+module Skr
+
+    # A SalesOrder is a record of a {Customer}'s desire to purchase one or more {Sku}s.
+    # It can be converted into an {Invoice} when the goods are delivered (or shipped)
+    # to the {Customer}
+    #
+    #     customer = Customer.find_by_code "VIP1"
+    #     so = SalesOrder.new( customer: customer )
+    #     Sku.where( code: ['HAT','STRING'] ).each do | sku |
+    #         so.lines.build( sku_loc: sku.sku_locs.default )
+    #     end
+    #     so.save
+    #
+    #     invoice = Invoice.new( sales_order: so )
+    #     invoice.lines.from_sales_order!
+    #     invoice.save
+
+
+    class SalesOrder < Skr::Model
+
+        has_visible_id
+        has_random_hash_code
+        is_order_like
+
+        belongs_to :customer, export: true
+        belongs_to :location, export: true
+        belongs_to :terms, class_name: 'Skr::PaymentTerm', export: { writable: true }
+        belongs_to :billing_address,  class_name: 'Skr::Address', export: { writable: true }
+        belongs_to :shipping_address, class_name: 'Skr::Address', export: { writable: true }
+
+        has_many   :lines, ->{ order(:position) }, :class_name=>'Skr::SoLine', :inverse_of=>:sales_order,
+                   extend: Concerns::SO::Lines, export: { writable: true }
+        has_many   :skus, through: :lines
+        has_many   :pick_tickets, inverse_of: :sales_order, before_add: :setup_new_pt
+        has_many   :invoices,     inverse_of: :sales_order, listen: { save: 'on_invoice' }
+
+        validates :location, :terms, :customer, set: true
+        validates :billing_address, :shipping_address, :order_date, presence: true
+        validate  :ensure_location_changes_are_valid
+
+        after_save :check_if_location_changed
+        before_validation :set_defaults, on: :create
+
+        delegate_and_export :customer_code, :customer_name
+        delegate_and_export :location_code, :location_name
+        delegate_and_export :terms_code,    :terms_description
+        delegate_and_export :billing_address_name
+
+
+        # joins the so_amount_details view which includes additional fields:
+        # customer_code, customer_name, bill_addr_name, total, num_lines, total_other_charge_amount,
+        # total_tax_amount, total_shipping_amount,subtotal_amount
+        scope :with_amount_details, lambda { | *args |
+            compose_query_using_detail_view(view: 'so_amount_details', join_to: 'sales_order_id')
+        }, export: true
+
+        # joins the so_allocation_details which includes the additional fields:
+        # number_of_lines,  allocated_total, number_of_lines_allocated, number_of_lines_fully_allocated
+        scope :with_allocation_details, lambda {
+            compose_query_using_detail_view(view: 'so_allocation_details', join_to: 'sales_order_id')
+        }
+
+        # a open SalesOrder is one who's state is not "complete" or "canceled"
+        scope :open, lambda { | *args |
+            where( arel_table[:state].not_in ['complete', 'canceled'] )
+        }, export: true
+
+        # a SalesOrder is allocated if it has one or more lines with qty_allocated>0
+        scope :allocated, lambda { | *unused |
+            with_allocation_details.where('details.number_of_lines_allocated>0')
+        }, export: true
+
+        # a SalesOrder is fully allocated when it has all it's lines allocated
+        scope :fully_allocated, -> {
+            allocated.where('details.number_of_lines=details.number_of_lines_allocated')
+        }, export: true
+
+        # a SalesOrder is considered pickable if either:
+        #   ship_partial=true and at least one line is allocated
+        #   all lines are fully allocated
+        scope :pickable, ->(unused=nil){
+            allocated.where("( ship_partial='t' and details.number_of_lines_allocated > 0 ) " \
+              " or ( details.number_of_lines=details.number_of_lines_fully_allocated)")
+        }, export: true
+
+        # @return [Array of Array[day_ago,date, order_count,line_count,total]]
+        def self.sales_history( ndays )
+            qry = "select * from #{Skr.config.table_prefix}so_dailly_sales_history where days_ago<#{ndays.to_i}"
+            connection.execute(qry).values
+        end
+
+        state_machine do
+            state :open, initial: true
+            state :complete
+            state :canceled
+
+            event :mark_complete do
+                transitions from: :open, to: :complete
+            end
+            event :mark_canceled do
+                transitions from: :open, to: :canceled
+                before :cancel_all_lines
+            end
+        end
+
+        def initialize(attributes = {})
+            super
+            self.order_date = Date.today
+        end
+
+      private
+
+        # When the location changes, lines need to have their sku_loc modified to point to the new location as well
+        def check_if_location_changed
+            if location_id_changed?
+                self.lines.each{ |l| l.location = self.location }
+            end
+        end
+
+        # The location can only be updated if all the line's skus are setup in the new location
+        def ensure_location_changes_are_valid
+            return true unless changes['location_id']
+            errors.add(:location, 'cannot be changed unless sales order is open') unless open?
+            current = self.sku_ids
+            setup   = location.sku_locs.where( sku_id: current ).pluck('sku_id')
+            missing = current - setup
+            if missing.any?
+                codes = Sku.where( id: missing ).pluck('code')
+                errors.add(:location, "#{location.code} does not have skus #{codes.join(',')}")
+            end
+        end
+
+        # Initialize a new {PickTicket} by copying the pickable lines to it
+        def setup_new_pt(pt)
+            self.lines.each do | so_line |
+                pt.lines << so_line.pt_lines.build if so_line.pickable_qty > 0
+            end
+            true
+        end
+
+        # when the order is canceled, inform the lines
+        def cancel_all_lines
+            self.pick_tickets.each{ |pt| pt.cancel! }
+            self.lines.each{ | soline | soline.cancel! }
+            true
+        end
+
+        def on_invoice(inv)
+            self.mark_complete! if may_mark_complete? and lines.unshipped.none?
+        end
+
+        def set_defaults
+            if customer
+                self.billing_address = customer.billing_address   if self.billing_address.blank?
+                self.shipping_address = customer.shipping_address if self.shipping_address.blank?
+            end
+        end
+    end
+end # Skr module

data/lib/skr/models/sequential_id.rb

@@ -0,0 +1,23 @@
+module Skr
+    class SequentialId < Skr::Model
+        FUNCTION_NAME="#{Skr.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/models/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      = Skr.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/models/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/models/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/models/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/models/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 = Skr.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