stockor 0.1.5

data/lib/skr/models/invoice.rb

@@ -0,0 +1,159 @@
+module Skr
+
+    # Invoices constitute a demand for payment for goods that have been delivered to a {Customer}.
+    # A invoice contains:
+    #
+    #   * Customer contact information
+    #   * An inventory location that goods will be taken from.
+    #   * The customer provided {PurchaseOrder} Number
+    #   * The Payment Terms that were extended. This will control how much time the Customer has to pay the invoice in full.
+    #   * One or more SKUs, the quantity desired for each and the selling price for them.
+    #
+    # While an {Invoice} often originates with a {SalesOrder}, it does not have to.
+    # Sales that take place in a retail environment where the customer selects
+    # the goods and pays for them immediately do not require a sales order record.
+    #
+    # Once an invoice is saved, it immediately removes the SKUs from the {SkuLoc}
+    # and generates corresponding General Ledger entries debiting the asset account
+    # and crediting the customers receivables account.
+    #
+    # When payment is received against the Invoice,
+    # the receivables account is debited and the payments holding account is credited.
+    #
+    #     invoice = Invoice.new( customer: Customer.find_by_code("ACME")
+    #     invoice.lines.build({ sku: Sku.find_by_code('LABOR'), qty: 1, price: 8.27 })
+    #     invoice.save
+
+    class Invoice < Skr::Model
+
+        has_visible_id
+        has_random_hash_code
+        has_gl_transaction
+        is_order_like
+        has_additional_events :amount_paid_change
+
+        belongs_to :sales_order,      export: true
+        belongs_to :customer,         export: true
+        belongs_to :location,         export: true
+        belongs_to :terms,            class_name: 'Skr::PaymentTerm', export: true
+        belongs_to :pick_ticket,      inverse_of: :invoice,      export: 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 :gl_transactions, :as=>:source
+
+        has_many :lines, -> { order(:position) }, class_name: 'Skr::InvLine', inverse_of: :invoice,
+                                                  extend: Concerns::INV::Lines, export: { writable: true }
+
+        before_save :maybe_mark_paid
+
+        before_validation :set_defaults, on: :create
+
+        validates :customer, :location, set: true
+        validate  :ensure_location_matches_so
+
+        scope :open_for_customer, lambda{ | customer |
+            where([ "customer_id=? and state != 'paid'", customer.is_a?(Customer) ? customer.id : customer ])
+        }, export: true
+
+        scope :with_details, lambda { |should_use=true |
+            compose_query_using_detail_view( view: 'inv_details', join_to: 'invoice_id' )
+        }, export: true
+
+        state_machine do
+            state :open, initial: true
+            state :paid
+            state :partial
+            event :mark_paid do
+                transitions from: [:open,:partial], to: :paid
+                before :apply_balances
+            end
+            event :mark_partial do
+                transitions from: [:open,:partial], to: :partial
+                before :apply_balances
+            end
+        end
+
+        def initialize(attributes = {})
+            super
+            self.invoice_date = Date.today
+        end
+
+        # @return [BigDecimal] total - amount_paid
+        def unpaid_amount
+            self.total - amount_paid
+        end
+
+        # @return [Boolean] is the invoice paid in full
+        def fully_paid?
+            unpaid_amount <= 0
+        end
+
+        private
+
+        # attributes for GlTransaction
+        def attributes_for_gl_transaction
+            {   location: location, source: self,
+                description: "INV #{self.visible_id}" }
+        end
+
+        # set the state if the amount_paid was changed
+        def maybe_mark_paid
+            return unless amount_paid_changed?
+            if self.fully_paid? && self.may_mark_paid?
+                self.state_event = 'mark_paid'
+            elsif self.amount_paid > 0 && self.may_mark_partial?
+                self.state_event = 'mark_partial'
+            end
+        end
+
+        def apply_balances
+            return unless amount_paid_changed?
+            change = amount_paid - amount_paid_was
+
+            Skr::Core.logger.debug "Applying payment #{amount_paid} changed: #{change}"
+
+            return if change.zero?
+
+            GlTransaction.push_or_save(
+              owner: self, amount: change,
+              debit: customer.gl_receivables_account, credit: GlAccount.default_for(:deposit_holding)
+            )
+            fire_event( :amount_paid_change )
+            true
+        end
+
+
+        def set_defaults
+
+            if pick_ticket
+                self.location    = pick_ticket.location
+                self.sales_order = pick_ticket.sales_order
+            end
+
+            if sales_order
+                self.terms          ||= sales_order.terms
+                self.customer         = sales_order.customer
+                self.po_num           = sales_order.po_num if self.po_num.blank?
+                self.billing_address  = sales_order.billing_address   if self.billing_address.blank?
+                self.shipping_address = sales_order.shipping_address  if self.shipping_address.blank?
+                self.options.merge!(sales_order.options)
+            end
+
+            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
+
+        def ensure_location_matches_so
+            if sales_order && location != sales_order.location
+                self.errors.add(:location, "#{location.code} must match location that order was taken on (#{sales_order.location.code})")
+            end
+        end
+
+    end
+
+
+end # Skr module

data/lib/skr/models/location.rb

@@ -0,0 +1,31 @@
+module Skr
+
+    # A location that holds inventory
+    class Location < Skr::Model
+
+        has_code_identifier :from=>'name'
+
+        belongs_to :address, export: { writable: true }
+
+        has_many :sku_locs
+
+        validates :gl_branch_code, :presence => true, :numericality=>true, :length=>{:is=>2}
+
+        locked_fields :gl_branch_code
+
+        before_validation :set_defaults, :on=>:create
+
+        # @return [Location] the location that's specified by {Skr::Core::Configuration#default_location_code}
+        def self.default
+            Location.find_by_code( Skr.config.default_location_code )
+        end
+
+      private
+
+        def set_defaults
+            self.gl_branch_code ||= Skr.config.default_branch_code
+            true
+        end
+
+    end
+end

data/lib/skr/models/payment_term.rb

@@ -0,0 +1,30 @@
+module Skr
+
+    # A pay
+    class PaymentTerm < Skr::Model
+
+        has_code_identifier
+
+        def discount
+            @discount_percnum ||= Core::Numbers::PercNum.new( read_attribute('discount_amount') )
+        end
+
+        def discount_amount=(value)
+            @discount_percnum = nil
+            super(value)
+        end
+
+        def immediate?
+            self.days.nil? || self.days.zero?
+        end
+
+        def discount_expires_at( start_date = Date.today )
+            ( start_date + self.discount_days.days ).to_date
+        end
+
+        def due_date_from( start_date = Date.today )
+            ( start_date + self.days.days ).to_date
+        end
+
+    end
+end

data/lib/skr/models/pick_ticket.rb

@@ -0,0 +1,71 @@
+module Skr
+
+    class PickTicket < Skr::Model
+
+        has_visible_id
+        is_order_like
+
+        belongs_to :sales_order
+        belongs_to :invoice, inverse_of: :pick_ticket, listen: { create: 'on_invoice' }
+        belongs_to :location
+
+        has_one :customer, through: :sales_order, export: true
+        has_one :terms,    through: :sales_order
+
+        has_many :lines, ->{ order(:position) }, class_name: 'Skr::PtLine', inverse_of: :pick_ticket,
+                 extend: Concerns::PT::Lines, export: { writable: true }
+
+        scope :with_details, lambda { | *args |
+            compose_query_using_detail_view( view: 'pt_details', join_to: 'pick_tickets_id' )
+        }, export: true
+
+        delegate :bill_addr, :to=>:sales_order
+
+        # If true, the PickTicket (and it's lines) will be marked as complete once it's saved
+        whitelist_attributes :mark_complete
+
+        before_update :check_for_mark_completed
+
+        validates  :sales_order, set: true
+        validates  :lines, presence: true
+        export_methods :ship_addr, :bill_addr
+
+        def ship_addr
+            sales_order.ship_addr.blank? ? sales_order.bill_addr : sales_order.ship_addr
+        end
+
+        def is_tax_exempt?
+            self.sales_order.is_tax_exempt?
+        end
+
+        def is_other_charge_locked?
+            return is_complete
+        end
+
+        def cancel!
+            update_attributes({ :is_complete=> true })
+            lines.each do | line |
+                line.update_attributes :is_complete=>true
+            end
+        end
+
+        private
+
+        def check_for_mark_completed
+            return unless self.mark_complete
+            assign_attributes :is_complete=>true
+            lines.each do | line |
+                line.update_attributes :is_complete=>true
+            end
+            true
+        end
+
+
+        def on_invoice(inv)
+            self.update_attributes is_complete: true, shipped_at: Time.now
+        end
+
+
+    end
+
+end # Skr module

data/lib/skr/models/po_line.rb

@@ -0,0 +1,69 @@
+module Skr
+
+    class PoLine < Skr::Model
+
+        acts_as_uom
+        is_sku_loc_line parent: 'purchase_order'
+
+        belongs_to :purchase_order, :inverse_of=>:lines
+        belongs_to :sku_loc,    export: true
+        belongs_to :sku_vendor, export: true
+
+        has_one :sku, :through => :sku_loc, export: true
+
+        has_many :receipts, class_name: 'Skr::PorLine',
+                 :inverse_of=>:po_line, listen: { create: :update_qty_received! }
+
+        validates :purchase_order, :sku_loc,  set: true
+        validates :description,    :sku_code, presence: true
+        validates :qty, :price,    numericality: true, allow_nil: false
+
+        locked_fields :qty, :qty_received
+
+        scope :incomplete, ->{ where('qty - qty_received - qty_canceled != 0' ) }
+
+        before_validation :set_defaults, :on=>:create
+
+        def qty_unreceived
+            qty - qty_received - qty_canceled
+        end
+
+        def complete?
+            qty_unreceived.zero?
+        end
+
+        def update_qty_received!( receipt=nil )
+            unlock_fields :qty_received do
+                self.qty_received = receipts.sum(:qty)
+                self.save( :validate => false )
+                if self.complete?
+                    self.purchase_order.set_maybe_completed!
+                end
+            end
+        end
+
+        private
+
+        def set_defaults
+            if sku_loc && sku_vendor.nil?
+                self.sku_vendor = sku_loc.sku.sku_vendors.for_vendor( purchase_order.vendor )
+            elsif sku_vendor && sku_loc.nil?
+                self.sku_loc = sku_vendor.sku.sku_locs.find_or_create_for( purchase_order.location )
+            end
+            if sku_loc
+                self.sku_code    ||= sku_loc.sku.code
+                self.description ||= sku_loc.sku.description
+            end
+            if sku_vendor
+                self.part_code  ||= sku_vendor.part_code
+                self.price      ||= sku_vendor.cost
+                self.uom_code   ||= sku_vendor.uom_code
+                self.uom_size   ||= sku_vendor.uom_size
+            end
+            true
+        end
+
+
+    end
+
+end # Skr module

data/lib/skr/models/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/models/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 }
+
+        whitelist_attributes :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/models/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/models/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_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