stockor-core 0.2

data/lib/skr/po_receipt.rb

@@ -0,0 +1,51 @@
+module Skr
+
+    # Is a record of an inventory receipt
+    # A {PurchaseOrder} can have one or more of them
+
+    class PoReceipt < Skr::Model
+
+        has_visible_id
+        has_sku_loc_lines
+        has_gl_transaction
+
+        belongs_to :purchase_order, export: true
+        belongs_to :vendor,   export: true
+        belongs_to :location, export: true
+
+        has_one :gl_transaction, :as=>:source
+
+        has_many :lines, :class_name=>'Skr::PorLine', export: { writable: true }, inverse_of: :po_receipt
+
+        validates :freight,        numericality: true
+        validates :purchase_order, :location, presence: true
+
+        before_create  :record_freight, if: ->{ freight.nonzero? }
+        after_create   :logit
+
+        def purchase_order=(po)
+            super
+            self.location   ||= purchase_order.location
+            self.vendor     = purchase_order.vendor
+        end
+
+        private
+
+        def attributes_for_gl_transaction
+            {   location: location, source: self,
+                description: "PO RECPT #{self.visible_id}" }
+        end
+
+        def logit
+        end
+
+        def record_freight
+            GlTransaction.current.add_posting( amount: self.freight,
+              debit: GlAccount.default_for( :inventory_receipts_clearing ),
+              credit: vendor.gl_freight_account
+            )
+        end
+
+    end
+
+end

data/lib/skr/por_line.rb

@@ -0,0 +1,80 @@
+module Skr
+
+    class PorLine < Skr::Model
+
+        acts_as_uom
+        is_sku_loc_line parent: 'po_receipt'
+
+        belongs_to :po_receipt
+        belongs_to :sku_loc,    export: true
+        belongs_to :po_line,    export: true
+        belongs_to :sku_vendor, export: true
+
+        has_one :sku, :through => :sku_loc, export: true
+
+        has_many :sku_trans, :as=>:origin, validate: true
+
+        before_create  :adjust_inventory
+        # after_update  :adjust_gl
+        validates :qty, numericality: { greater_than: 0 }
+
+        json_attr_accessor :auto_allocate
+
+        def po_line=(pol)
+            super
+            %w{ sku_code part_code description uom_code uom_size }.each do | attr |
+                self[ attr ] = po_line[ attr ]
+            end
+            self.sku_loc    = pol.sku_loc
+            self.sku_vendor = pol.sku_vendor
+            self.uom   = pol.uom
+            self.price = pol.price
+            self.qty   = pol.qty_unreceived
+        end
+
+        private
+
+        def adjust_inventory
+            Core.logger.debug( "Receiving #{self.ea_qty} into stock" )
+            tran = self.sku_trans.build({
+                origin: self, qty: self.qty,
+                sku_loc: po_line.sku_loc,
+                origin_description: "PO #{self.po_line.purchase_order.visible_id}",
+                cost: self.extended_price,  uom: self.uom,
+                credit_gl_account: self.sku.gl_asset_account,
+                debit_gl_account:  GlAccount.default_for( :inventory_receipts_clearing )
+            })
+            if self.auto_allocate
+                tran.allocate_after_save = true
+            end
+            true
+        end
+
+        def ensure_qty_is_less_than_unreceived
+            if qty_changed? && po_line && qty > po_line.qty_unreceived
+                errors.add(:qty,"#{qty} must be less than unreceived qty of #{po_line.qty_unreceived}")
+            end
+        end
+
+        def adjust_gl
+            diff = price - price_was
+            return if diff.zero?
+
+            tran = self.sku_trans.build({ :origin=>self, :qty => 0, :sku_loc=>po_line.sku_loc,
+                :credit_gl_account => self.sku.gl_asset_account,
+                :uom_size=>self.uom_size, :uom_code=>self.uom_code })
+
+            tran.cost = diff * qty
+
+            tran.debit_gl_account = if voucher.confirmed?
+                                        voucher.vendor.gl_payables_account
+                                    else # otherwise it's in the clearing account
+                                        GlAccount.default_for( :inventory_receipts_clearing )
+                                    end
+            tran.save!
+
+        end
+
+
+    end
+end

data/lib/skr/pt_line.rb

@@ -0,0 +1,74 @@
+module Skr
+
+    class PtLine < Skr::Model
+
+        acts_as_uom
+        is_sku_loc_line parent: 'pick_ticket'
+
+        attr_accessor :qty_to_ship
+
+        belongs_to :pick_ticket, export: true
+        belongs_to :sku_loc,     export: true
+        belongs_to :so_line
+
+        has_one :inv_line, inverse_of: :pt_line, listen: { save: :update_from_inv_line }
+        has_one :sales_order, :through=>:pick_ticket, export: true
+        has_one :sku,         :through => :sku_loc, export: true
+
+        scope :picking, ->{ where({ :is_complete=>false }) }
+
+        delegate_and_export_field  :pick_ticket, :visible_id
+        delegate_and_export_field  :sales_order, :visible_id
+
+        before_create :set_defaults#, on: :create
+
+        def cancel!
+            self.update_attributes! :is_complete=>true
+            self.pick_ticket.maybe_cancel
+        end
+
+        def is_invoiceable?
+            ! self.is_complete? && self.qty_to_ship.to_i > 0
+        end
+
+        def total
+            self.price * ( self.qty_to_ship || self.qty )
+        end
+
+        private
+
+        def update_from_inv_line( inv_line )
+            self.update_attributes( qty_invoiced: inv_line.qty )
+        end
+
+        def set_defaults
+
+            if self.so_line.blank?
+                self.so_line = self.pick_ticket.sales_order.lines.where({ sku_loc_id: self.sku_loc_id }).first
+            end
+
+            if self.so_line.blank?
+                self.so_line = self.pick_ticket.sales_order.lines.create({
+                    sku_loc: self.sku_loc, qty: self.qty, price: self.price,
+                    uom: self.uom, description: self.description
+                })
+                unless self.so_line.valid?
+                    self.errors.add(:so_line, "cannot be created because #{self.so_line.errors.full_messages.join(', ')}" )
+                    return false
+                end
+            end
+
+            self.sku_loc     ||= so_line.sku_loc
+            self.bin         ||= sku_loc.bin
+            self.price       ||= so_line.price
+            self.sku_code    = sku_loc.sku.code    if self.sku_code.blank?
+            self.description = so_line.description if self.description.blank?
+            self.uom         = so_line.uom         if self.uom.blank?
+            true
+        end
+
+
+    end
+
+
+end # Skr module

data/lib/skr/purchase_order.rb

@@ -0,0 +1,112 @@
+module Skr
+
+    # A Purchase Order (often abbreviated as PO)
+    # is a record of a request to purchase a product from a Vendor.
+    # It contains one or more {Sku}, the quantity desired for each and the price offered for them.
+    #
+    # A Purchase Order progresses through set stages:
+    #
+    #   * It starts of as "saved"
+    #     This state indicates that the PO has been saved but no further action has been under-taken.
+    #   * Once it has been sent to the Vendor, it transitions to Sent.
+    #   * On reciept of a confirmation from the vendor it becomes Confirmed At this point the PO may be
+    #     considered a binding agreement with the {Vendor}.
+    #   * When the ordered SKUs are received, the PO will be marked as either Partial or Complete.
+    #   * A {PoReceipt} is then created from the Purchase Order.
+
+    class PurchaseOrder < Skr::Model
+
+        has_visible_id
+
+        belongs_to :terms,    export: true, class_name: 'Skr::PaymentTerm'
+        belongs_to :vendor,   export: true
+        belongs_to :location, export: true
+        belongs_to :ship_addr, :class_name=>'Skr::Address', export: { writable: true }
+
+        has_many :lines, ->{ order(:position) }, :class_name=>'Skr::PoLine', :inverse_of=>:purchase_order, export: {writable:true}
+        has_many :receipts, class_name: 'Skr::PoReceipt'
+
+        before_validation :set_defaults, :on=>:create
+
+        validates :vendor,  :location, :terms, :presence=>true
+
+        delegate_and_export :vendor_code, :vendor_name
+        delegate_and_export :location_code
+        delegate_and_export :terms_code, :terms_description
+
+        export_methods :total
+
+        blacklist_json_attributes :receiving_completed_at
+
+        after_save :set_maybe_completed!
+
+        export_join_tables :details
+        export_scope :with_details, lambda { |should_use=true |
+            joins('join po_details as details on details.purchase_order_id = purchase_orders.id')
+            .select('purchase_orders.*, details.*') if should_use
+        }
+
+        export_scope :only_incoming, lambda { |should_use=true|
+            with_details.where("state !='received'") if should_use
+        }
+
+        state_machine do
+            state :open, initial: true
+            state :received
+
+            event :mark_received do
+                transitions from: :open, to: :received
+                before do
+                    self.receiving_completed_at = Time.now
+                end
+            end
+        end
+
+        def after_message_transmitted( msg )
+            self.mark_transmitted if self.can_mark_transmitted?
+        end
+
+        def set_maybe_completed!
+            self.mark_received! unless received? or self.lines.incomplete.any?
+        end
+
+        def to_shipping_address
+            Address.copy_from(self,'ship_')
+        end
+
+        def set_message_fields( msg )
+            msg.recipient = self.vendor.payments_address.email_with_name  if msg.recipient.blank?
+            msg.subject   = "Purchase Order # #{self.visible_id}"
+            attach = msg.attachments.build
+            attach.set_type_to_pdf
+            pdf = self.as_pdf
+            attach.file = pdf
+        end
+
+        def as_pdf( opts={} )
+            defaults = { :purchase_order => self, :include_received=>false }
+            Latex::Runner.new( 'purchase_order', defaults.merge( opts ) ).pdf( "PurchaseOrder_#{self.visible_id}.pdf" )
+        end
+
+        def total
+            if total = self.read_attribute('total')
+                BigDecimal.new(total)
+            elsif self.association(:lines).loaded?
+                self.lines.inject(0){|sum,line| sum + line.total }
+            else
+                BigDecimal.new( self.lines.sum('price*qty') )
+            end
+        end
+
+        private
+
+        def set_defaults
+            self.location   ||= Location.default
+            self.order_date ||= Date.today
+            self.terms      ||= self.vendor.terms if self.vendor
+            self.ship_addr    = self.location.address if self.ship_addr.blank? && self.location
+        end
+    end
+
+
+end # Skr module

data/lib/skr/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::Core.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