stockor-core 0.2

data/lib/skr/uom.rb

@@ -0,0 +1,63 @@
+module Skr
+
+    class Uom < Skr::Model
+
+        belongs_to :sku, :inverse_of=>:uoms
+
+        validates :price,  :numericality=>true, :allow_nil=>false
+        validates :sku,    :presence=>true, :on=>:update
+        validates :code,   :presence=>true
+        validates :size,   :numericality => true, :length=>{:minimum=>1}
+        validates :weight, :height, :width, :depth, :numericality=>{:greater_than=>0.1}, :allow_nil=>true
+
+        export_methods :combined_uom, mandatory: true
+
+        def combined_uom
+            if self.size.nil? || self.code.nil?
+                ''
+            elsif 1 == self.size
+                self.code
+            else
+                "#{self.code}/#{self.size}"
+            end
+        end
+
+        def has_dimensions?
+            ! self.dimensions.include?(nil)
+        end
+
+        def dimensions
+            [ width, height, depth ]
+        end
+
+        def volume
+            if has_dimensions?
+                dimensions.inject(:*)
+            else
+                nil
+            end
+        end
+
+        def blank?
+            self.code.blank? || self.size.to_i == 0
+        end
+
+
+        def self.ea
+            Uom.new({ :code=>'EA',:size=>1, :price=>0.0 })
+        end
+
+    end
+
+
+end # Skr module
+
+
+__END__
+
+        def for_public(user=nil,options={})
+            as_json({
+                :only=>%w{ code size base_price },
+                :methods=>%w{ combined_uom dimensions volume }
+            })
+        end

data/lib/skr/user_proxy.rb

@@ -0,0 +1,60 @@
+module Skr
+
+    # The UserProxy is a stand-in for the real user
+    # model that will be implementation specific by the user of Stockor Core
+    class UserProxy
+
+        # The user who's currently interacting with Stockor.
+        # Defaults to 0, indicating anonymous or unknown
+        # @return [Object,FixNum] whatever was set using scoped_to, or 0 if nothing was set
+        def self.current
+            Thread.current[:skr_user_proxy]
+        end
+
+        # Retrieve the current id of the user we're proxying for.
+        # get's a bit complicated since we can proxy both for a user object
+        # or just the user's id
+        # @return [Fixnum] current user's ID.  If the current user is not set, returns 0
+        def self.current_id
+            if self.current.nil?
+                0
+            else
+                self.current.is_a?(Fixnum) ? self.current : self.current.id
+            end
+        end
+
+        # sets the user for the duration of the block
+        # @example Inside a Rails controller
+        #
+        #     class DocumentsController < ApplicationController
+        #         around_filter :set_skr_user
+        #
+        #         # update's the Document's owner to current
+        #         # But sets all the notes to be owned by admin
+        #         def update_owner
+        #             doc = Document.find(params[:id])
+        #             doc.current_owner = Skr::UserProxy.current
+        #             Skr::UserProxy.scoped_to( User.admin ) do
+        #                 doc.notes.each{ |note| note.set_owner_to_current! } # will set to Skr::UserProxy.current
+        #             end
+        #         end
+        #
+        #         private
+        #
+        #         def set_skr_user
+        #             user = SuperUserModel.find( session[:user] )
+        #             Skr::UserProxy.scoped_to( user ) do
+        #                  yield
+        #             end
+        #          end
+        #      end
+        #
+        # @return [UserProxy] self
+        def self.scoped_to( user )
+            prev_user, Thread.current[:skr_user_proxy] = self.current, user
+            yield user
+        ensure
+            Thread.current[:skr_user_proxy] = prev_user
+        end
+    end
+end

data/lib/skr/validators/all.rb

@@ -0,0 +1,2 @@
+require_relative "set"
+require_relative "email"

data/lib/skr/validators/email.rb

@@ -0,0 +1,17 @@
+# A custom validator "email".
+# Doesn't really validate an email completely
+# It simply asserts that the email string has one (and only one)
+# @ (at symbol). This is mainly
+# to give user feedback and not to assert the e-mail validity.
+
+class EmailValidator < ActiveModel::EachValidator
+
+    # Regex originated from the Devise gem
+    REGEX = /\A[^@]+@([^@\.]+\.)+[^@\.]+\z/
+
+    def validate_each( rec, attr, value)
+        unless value.present? && value.match( REGEX )
+            rec.errors.add attr, options[:message] || 'does not appear to be a valid email'
+        end
+    end
+end

data/lib/skr/validators/set.rb

@@ -0,0 +1,18 @@
+# A custom validator "set".  It's similar to :presence validator
+# Unlike :presence, :set doesn't care whether the associated record is valid or not, just that it is present
+# Also unlike :presence, it only works on belongs_to
+class SetValidator < ActiveModel::EachValidator
+
+    def validate_each( record, attribute, value)
+        association = record.class.reflect_on_association( attribute )
+
+        if association.nil? || !association.belongs_to?
+            raise ArgumentError, "Cannot validate existence on #{record.class} #{attribute}, not a :belongs_to association"
+        end
+
+        if record.send( attribute ).nil?
+            record.errors.add( attribute, "is not set")
+        end
+
+    end
+end

data/lib/skr/vendor.rb

@@ -0,0 +1,33 @@
+module Skr
+
+    # Vendors is a companies you purchase goods and services from.
+    # They have both a billing and shipping address,
+    # a gl account that payables should be applied against, and a payment term.
+    class Vendor < Skr::Model
+
+        # Common code shared with {Customer}
+        include BusinessEntity
+
+        belongs_to :gl_payables_account, class_name: 'Skr::GlAccount', export: true
+        belongs_to :gl_freight_account,  class_name: 'Skr::GlAccount', export: true
+
+        has_many :purchase_orders, inverse_of: :vendor
+        has_many :vouchers,        inverse_of: :vendor
+        has_many :vendor_skus,     class_name: 'Skr::SkuVendor', inverse_of: :vendor
+
+        delegate_and_export  :gl_payables_account_number
+        validates :gl_payables_account, set: true
+
+        has_many :sku_vendors
+
+        private
+
+        def set_defaults
+            self.terms               ||= PaymentTerm.find_by_code(Core.config.customer_terms_code)
+            self.gl_payables_account ||= GlAccount.default_for( :ap )
+            self.gl_freight_account  ||= GlAccount.default_for( :freight )
+        end
+
+    end
+
+end # Skr module

data/lib/skr/vo_line.rb

@@ -0,0 +1,35 @@
+module Skr
+
+    class VoLine < Skr::Model
+
+        acts_as_uom
+
+        is_sku_loc_line parent: 'voucher'
+
+        belongs_to :voucher
+        belongs_to :sku_vendor
+        belongs_to :po_line
+        has_one :sku, :through => :sku_vendor, export: true
+
+        validates :sku_vendor, :voucher,   set: true
+        validates :sku_code, :description, :presence => true
+
+        validate :qty, numericality: { gt: 0 }
+
+        before_validation :set_defaults, one: :create
+
+        private
+
+        def set_defaults
+            if po_line
+                self.sku_vendor = po_line.sku.sku_vendors.for_vendor( self.voucher.vendor )
+                %w{ price sku_code part_code description uom_code uom_size }.each do | attr |
+                    self[ attr ] ||= po_line[ attr ]
+                end
+            end
+            true
+        end
+    end
+
+
+end # Skr module

data/lib/skr/voucher.rb

@@ -0,0 +1,119 @@
+module Skr
+
+    # A voucher is a record of a {Vendor}'s demand for payment, or a record of
+    # It transistions through the following states
+    #
+    #  * Saved; A {PurchaseOrder} has been recieved but an Invoice has not been received fromt the Vendor
+    #     * It credit's each line's {Sku#gl_asset_account} and debit's the System default inventory_receipts_clearing
+    #  * Confirmed; An Invoice has been received and verified as accurate.
+    #     * Debit: {Vendor#gl_payables_account}, Credit: inventory_receipts_clearing
+    #  * Paid;  A payment has been made against the Voucher
+    #     * Debit {Vendor#gl_payables_account}, Credit: Deposit clearing account
+    class Voucher < Skr::Model
+
+        has_visible_id
+
+        has_sku_loc_lines
+
+        belongs_to :vendor,   export: true
+        belongs_to :customer, export: true
+
+        belongs_to :purchase_order
+        belongs_to :terms, :class_name=>'Skr::PaymentTerm', export: true
+        belongs_to :location
+
+        has_many :gl_transactions, :as=>:source
+        has_many :lines, :class_name=>'Skr::VoLine', export: { writable: true },
+                 :inverse_of=>:voucher, :autosave=>true, validate: true
+
+        before_validation :set_defaults, :on=>:create
+
+        export_scope :with_details, lambda { | *args |
+            compose_query_using_detail_view( view: 'vo_details', join_to: 'voucher_id' )
+        }
+
+        export_scope :unpaid, lambda{ | unused=nil |
+            where(['vouchers.state <> ? and payment_lines.id is null', 'pending']).includes(:payment_line)
+        }
+
+        state_machine do
+            state :pending, initial: true
+            state :confirmed
+            state :paid
+
+            event :mark_confirmed do
+                transitions from: :pending, to: :confirmed
+                before :record_confirmation_in_gl
+            end
+
+            event :mark_paid do
+                transitions from: :confirmed, to: :paid, guards: :ensure_payment_line
+                before :record_payment_in_gl
+            end
+
+
+        end
+
+        def po_receipt=(por)
+            self.vendor = por.vendor
+            self.purchase_order = por.purchase_order
+            self.terms = self.purchase_order.terms
+            self.refno = por.refno
+        end
+
+        # def payment_line=(pl)
+        #     pl.refno = self.refno
+        #     pl.description = "Payment on PO #{self.visible_id}"
+        #     super
+        # end
+
+        # def description_for_gl_transaction(gl_tran)
+        # end
+
+        # def does_create_own_gl_records?
+        #     true
+        # end
+
+        private
+
+        def ensure_payment_line
+            payment_line.present?
+        end
+
+        def set_defaults
+#            self.freight  ||= 0.0
+            if self.purchase_order
+                self.vendor   = self.purchase_order.vendor
+                #self.location = self.purchase_order.location
+                self.terms  ||= self.purchase_order.terms
+            end
+        end
+
+
+
+        def record_confirmation_in_gl
+            self.confirmation_date ||= Date.today
+            GlTransaction.push_or_save(
+              :owner   =>  self, amount: total,
+              :debit   =>  vendor.gl_payables_account,
+              :credit  => GlAccount.default_for( :inventory_receipts_clearing ),
+              :options => { description: "Voucher #{self.visible_id}" }
+            )
+            true
+        end
+
+        def record_payment_in_gl
+            gl = self.gl_transactions.build({
+                :source      =>self,
+                :location    => self.purchase_order.location,
+                :amount      =>self.total,
+                :description =>'Voucher Payment' })
+            gl.credit.account = self.vendor.gl_payables_account
+            gl.debit.account  = self.payment_line.payment.bank_account.gl_account
+            gl.save!
+        end
+
+    end
+
+
+end # Skr module

data/lib/stockor/core.rb

@@ -0,0 +1,9 @@
+require_relative '../skr/core'
+
+# This is a "sham" namespace that only exists so that
+# Bundler will pull in the Skr::Core namespace
+module Stockor
+    module Core
+        VERSION = Skr::Core::VERSION
+    end
+end

data/stockor-core.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'skr/core/version'
+
+Gem::Specification.new do |spec|
+
+  spec.name          = "stockor-core"
+  spec.version       = Skr::Core::VERSION
+  spec.authors       = ["Nathan Stitt"]
+  spec.email         = ["nathan@argosity.com"]
+
+  spec.summary       = %q{Stockor Core contains the models for the Stockor ERP system}
+  spec.description   = %q{Stockor Core contains the ActiveRecord models and business logic for the Stockor ERP system}
+
+  spec.homepage      = "http://stockor.org/"
+  spec.license       = "GPL-3.0"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^test/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 2.0'
+  spec.add_dependency 'activerecord', '~> 4.1'
+  spec.add_dependency 'pg', '~> 0.17'
+  spec.add_dependency 'aasm', '~>3.1'
+  spec.add_dependency "require_all",  '~> 1.3'
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "growl"
+  spec.add_development_dependency "pry-plus"
+  spec.add_development_dependency "guard-minitest"
+
+
+end

data/tasks/migrations.rake

@@ -0,0 +1,23 @@
+require 'active_record'
+require 'active_support/core_ext/string/strip'
+require 'fileutils'
+require 'skr/core'
+## quite a bit of this is cribbed from Sinatra ActiveRecord
+
+load 'active_record/railties/databases.rake'
+require 'rake'
+
+
+namespace :db do
+
+    task :environment do
+        Skr::Core::DB.configure_rake_environment
+    end
+
+    desc "create an ActiveRecord migration"
+    task :create_migration,[ :name ] do | t, args |
+        Skr::Core::DB.create_migration( "create_skr_" + args[:name] )
+    end
+
+
+end

data/tasks/publish.rake

@@ -0,0 +1,8 @@
+namespace :publish do
+
+    desc "generate and publish docs to stockor.org"
+    task :docs => 'doc' do
+        system( "rsync", "doc/", "-avz", "--delete", "stockor@stockor.org:~/docs/core")
+    end
+
+end

data/test/address_test.rb

@@ -0,0 +1,57 @@
+require_relative 'test_helper'
+
+class AddressTest < Skr::TestCase
+
+    def test_creation
+        addr=Address.new( name:" a test", email:"test@test.com" )
+        assert_saves addr
+    end
+
+    def test_email_with_name
+        addr=Address.new( email: 'john@mcauthor.com', name: 'John D. McAuthor' )
+        assert_equal "John D. McAuthor <john@mcauthor.com>", addr.email_with_name
+    end
+
+    def test_blankness
+        addr = Address.blank
+        assert addr.blank?, "Blank address isn't blank?"
+        %w{ name line1 city state postal_code }.each do | attr |
+            assert addr.blank?
+            addr[ attr ] = "something"
+        end
+        refute addr.blank?
+    end
+
+    def test_separated_name
+        addr=Address.new( name: 'John D McAuthor' )
+        assert_equal 'John', addr.seperated_name[:first]
+        assert_equal 'McAuthor', addr.seperated_name[:last]
+    end
+
+    def test_selective_validations
+        addr=Address.blank
+        assert addr.save
+        addr.enable_validations
+        refute addr.save
+        %w{ name line1 city state postal_code }.each do | attr |
+            addr[ attr ] = "something"
+        end
+        assert addr.save
+        addr.enable_validations include_email: true
+        refute addr.save
+        addr.email = "test" # <- no '@'
+        refute addr.save
+        addr.email = "test@test.com" # <- no '@'
+        assert addr.save
+        addr.enable_validations include_phone: true
+        refute addr.save
+        addr.phone = "555-555-5555"
+        assert addr.save
+    end
+
+    def test_converting_to_string
+        addr = skr_addresses(:office)
+        assert_equal "Argosity Office\n619 E Capitol Ave\nJefferson City Missouri, 65101", addr.to_s
+    end
+
+end