stockor-core 0.2

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

data/lib/skr/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/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( Core.config.default_location_code )
+        end
+
+      private
+
+        def set_defaults
+            self.gl_branch_code ||= Skr::Core.config.default_branch_code
+            true
+        end
+
+    end
+end

data/lib/skr/model.rb

@@ -0,0 +1,37 @@
+require_relative 'concerns/all'
+
+module Skr
+
+    def self.table_name_prefix
+        Skr::Core.config.table_prefix
+    end
+
+
+    class Model < ::ActiveRecord::Base
+        self.abstract_class = true
+
+        include Concerns::Queries
+        include Concerns::PubSub
+        include Concerns::JsonAttributeAccess
+        include Concerns::TrackModifications
+        include Concerns::LockedFields
+        include Concerns::CodeIdentifier
+        include Concerns::RandomHashCode
+        include Concerns::VisibleIdIdentifier
+
+        include Concerns::ImmutableModel
+        include Concerns::ExportMethods
+        include Concerns::ExportScope
+        include Concerns::ExportAssociations
+        include Concerns::ExportJoinTables
+        include Concerns::SanitizeJson
+        include Concerns::ActsAsUOM
+        include Concerns::StateMachine
+        include Concerns::HasSkuLocLines
+        include Concerns::HasGlTransaction
+        include Concerns::IsOrderLike
+        include Concerns::IsSkuLocLine
+        include Concerns::AssociationExtensions
+    end
+
+end

data/lib/skr/null_user.rb

@@ -0,0 +1,30 @@
+module Skr
+
+    # Implements the interface for a User model in Stockor
+    # This implementation grants access to everything
+    class NullUser
+        # Used to track created_by and updated_by
+        def id
+            0
+        end
+        # @param model [Skr::Model]
+        # @param attribute [Symbol]
+        # @return [Boolean] Can the User view the model?
+        def can_read?( model, attribute=nil)
+            true
+        end
+
+        # @param model [Skr::Model]
+        # @param attribute [Symbol]
+        # @return [Boolean] Can the User create and update the model?
+        def can_write?(model, attribute=nil)
+            true
+        end
+
+        # @param model [Skr::Model]
+        # @return [Boolean] Can the User delete the model?
+        def can_delete?(type, model)
+            true
+        end
+    end
+end

data/lib/skr/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/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
+        json_attr_accessor :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/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