stockor 0.1.5

data/lib/skr/concerns/locked_fields.rb

@@ -0,0 +1,84 @@
+module Skr
+    module Concerns
+
+        # @see ClassMethods
+        module LockedFields
+            extend ActiveSupport::Concern
+
+            module ClassMethods
+                # Mark fields as locked, meaning they cannot be updated by using the
+                # regular attribute update methods.  Instead it must be called in an unlock block
+                # Relies on attr_readonly internally
+                #
+                # Is used to designate sensitive fields that we want to make sure someone's thought about before updating
+                # Also solves the age old single equals vs double equals bug/typo.
+                #
+                #     class BankAccount < Skr::Model
+                #
+                #     end
+                #
+                #     bank=BankAccount.find(1)
+                #     b.mark_as_super if bank.account_balance = 42 # a bit contrived, but you get the idea
+                #     b.save # oops, what's our balance now?
+                #
+                #  Now let's try it again with locked_fields
+                #
+                #     class BankAccount < Skr::Model
+                #         attr_readonly :account_balance
+                #     end
+                #
+                #     bank=BankAccount.find(1)
+                #     b.mark_as_super if bank.account_balance = 42
+                #     b.save # Still not ideal since we marked the bank as super, but at least our balance is ok
+                #
+                #  To update the balance we'd need to:
+                #
+                #     b.unlock_fields( :account_balance ) do
+                #         b.account_balance += 33
+                #     end
+                #     b.save
+                #
+                #  This is still a bit contrived since we'd actually have
+                #  an audit logger that would be involved and it'd be inside a transaction.
+
+                def locked_fields( *flds )
+                    include InstanceMethods
+                    attr_readonly( *flds )
+                end
+
+                def has_locks( *locks )
+                    locks.each do | lock |
+                        define_method( "unlock_#{lock}" ) do | &block |
+                            instance_variable_set "@_lock_#{lock}_unlocked", true
+                            block.call
+                            remove_instance_variable "@_lock_#{lock}_unlocked"
+                        end
+                        define_method( "is_#{lock}_unlocked?") do
+                            instance_variable_defined? "@_lock_#{lock}_unlocked"
+                        end
+                    end
+                end
+
+            end
+
+            module InstanceMethods
+                # Unlock the field for updates inside the block
+                # yields, then restores it.
+                # Is class wide, meaning it Will temporarily open all instances of the class up for access in a threaded environment
+                def unlock_fields( *flds, &block )
+                    attr_syms = flds.map(&:to_s)
+
+                    self.class.attr_readonly.subtract( attr_syms )
+
+                    yield
+
+                    attr_syms.each do | fld |
+                        self.class.attr_readonly.add( fld )
+                    end
+
+                end
+            end
+
+        end
+    end
+end

data/lib/skr/concerns/pt_extensions.rb

@@ -0,0 +1,22 @@
+module Skr
+    module Concerns
+
+        module PT
+
+            module Lines
+
+                def set_ship_qty
+                    each{|l| l.qty_to_ship = l.qty }
+                end
+
+                def ea_picking_qty
+                    if proxy_association.loaded?
+                        inject(0){ | sum, ptl | sum+(ptl.qty*ptl.uom_size) unless ptl.is_complete? }
+                    else
+                        where( is_complete: false ).sum('qty*uom_size')
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/skr/concerns/random_hash_code.rb

@@ -0,0 +1,40 @@
+module Skr
+    module Concerns
+
+        # @see ClassMethods
+        module RandomHashCode
+
+            extend ActiveSupport::Concern
+
+            # ### Random Hash Code Concern
+            # This adds the {#has_random_hash_code} class method
+            module ClassMethods
+
+                # A random string that identifies an entity, such as a Customer, or Vendor
+                # The code is generated by {Skr::Strings.random} for new records
+                # It's useful for generating *magic* links for access to an entity that cannot be guessed.
+                # @param field_name [Symbol] which field should the hash_code be stored in
+                # @param length [Integer] how long the hash_code should be
+
+                def has_random_hash_code( field_name: :hash_code, length: 12 )
+
+                    validates field_name, :presence=>{
+                        :message=>"hash code is not set (should be automatically chosen)"
+                    }
+
+                    scope :with_hash_code, lambda{ | code |
+                        where({ :hash_code=>code })
+                    }
+
+                    before_validation(:on=>:create) do
+                        self[ field_name ] = Lanes::Strings.random( length ) if self[ field_name ].blank?
+                    end
+
+                end
+            end
+
+        end
+
+    end
+
+end

data/lib/skr/concerns/so_extensions.rb

@@ -0,0 +1,30 @@
+module Skr
+    module Concerns
+
+        module SO
+
+            module Lines
+
+                def set_ship_qty
+                    each{|l| l.qty_to_ship = l.qty }
+                end
+
+                def eq_qty
+                    if proxy_association.loaded?
+                        inject(0){ | sum, sol | sum + (sol.eq_qty*uom_size) }
+                    else
+                        sum('qty*uom_size')
+                    end
+                end
+
+                def eq_qty_allocated
+                    if proxy_association.loaded?
+                        inject(0){ | sum, sol | sum + (sol.qty_allocated * uom_size) }
+                    else
+                        sum('qty_allocated*uom_size')
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/skr/concerns/state_machine.rb

@@ -0,0 +1,61 @@
+require 'aasm' # Acts As State Machine
+
+module Skr
+    module Concerns
+
+
+        # Models that use the {https://github.com/aasm/aasm}
+        # gem to track object state
+        module StateMachine
+
+            extend ActiveSupport::Concern
+
+            module ClassMethods
+
+                # Mark class as a StateMachine {https://github.com/aasm/aasm}
+                #
+                # Specifically it:
+                #
+                #   * Adds the methods in {InstanceMethods} to the class
+                #   * Blacklists the "state" field so it cannot be set via the API
+                #   * Allows access to the "state_event" pseudo field from the API
+                #   * Sets up the aasm library with the contents of &block
+                def state_machine( options={}, &block )
+                    include InstanceMethods
+                    include AASM
+                    aasm( options.merge( column: 'state' ), &block )
+
+                    whitelist_attributes :state_event
+
+                    export_methods :valid_state_events, :optional=>false
+                    blacklist_attributes :state
+
+                    before_save :fire_state_machine_event_on_save
+                end
+
+            end
+
+            module InstanceMethods
+
+                def fire_state_machine_event_on_save
+                    return unless state_event.present?
+                    event_name = state_event.to_sym
+                    if valid_state_events.include?( event_name )
+                        self.send( :aasm_fire_event, event_name,  {:persist=>false} )
+                    else
+                        errors.add(:state_event, "is not valid")
+                        false
+                    end
+                end
+
+                # @return [Array of symbols] the available state_transistions
+                def valid_state_events
+                    aasm.events
+                end
+
+            end
+
+        end
+
+    end
+end

data/lib/skr/concerns/visible_id_identifier.rb

@@ -0,0 +1,53 @@
+module Skr
+    module Concerns
+
+        # @see ClassMethods
+        module VisibleIdIdentifier
+
+            extend ActiveSupport::Concern
+
+            module InstanceMethods
+
+                # setup the visible id to the next available #{Skr::SequentialId}
+                # @return [Integer] the assigned ID
+                def assign_visible_id!
+                    self.visible_id = Skr::SequentialId.next_for( self.class )
+                end
+            end
+
+
+            # ### Visible ID Identifier Concern
+            # This adds the {#has_visible_id} class methods
+            module ClassMethods
+
+                # An auto-incrementing number that's user-visible.
+                # The visible_id is stored as an integer, but a string index is generated for
+                # querying by the sql like operator. The **with_visible_id** scope is available for this purpose
+                #
+                # The next number an also be adjusted by the end-user by setting {Skr::SequentialId}
+                # so they can set the numbers to start at
+                # a specific point, which is useful for getting Invoice and other
+                # numbers to match up to a legacy system
+                def has_visible_id
+                    include InstanceMethods
+                    validates :visible_id, :presence=>{
+                                  :message=>"ID was not set (should be automatically chosen)"
+                              }
+                    alias_attribute :record_identifier, :visible_id
+                    before_validation :assign_visible_id!, :on=>:create
+
+                    export_scope :with_visible_id, lambda{ | visid |
+                        if visid.to_s =~/%/
+                            where( 'cast(visible_id as varchar) like ?', visid.to_s )
+                        else
+                            where( 'cast(visible_id as varchar) = ?',    visid.to_s )
+                        end
+                    }
+
+                end
+
+            end
+        end
+
+    end
+end

data/lib/skr/configuration.rb

@@ -0,0 +1,68 @@
+require 'lanes/configuration'
+require_relative 'standard_pricing_provider'
+
+module Skr
+
+    class Configuration < Lanes::Configuration
+
+        # Database tables will have this prefix applied to them
+        config_option :table_prefix, 'skr_'
+
+        # The GL branch code to use for default newly created locations
+        config_option :default_branch_code, '01'
+
+        # The string value of the UserModel.  Will be set on model's updated_by and created_by
+        config_option :user_model, 'UserProxy'
+
+        # Transactions that do not specify a location will use the one that's identified by this code
+        config_option :default_location_code, 'DEFAULT'
+
+        # Do freshly created SKUs default to being backorderable?
+        config_option :skus_backorder_default, true
+
+        # The code for a Sku that represents tax
+        config_option :tax_sku_code, 'TAX'
+
+        # Code for a Sku that represents shipping charges
+        config_option :ship_sku_code, 'SHIP'
+
+        # Code for a PaymentTerm that will be used as the default for new Customers
+        config_option :customer_terms_code, 'CASH'
+
+        # Code for a PaymentTerm that will be used as the default for new Vendors
+        config_option :vendor_terms_code, 'CASH'
+
+        config_option :pricing_provider, Skr::StandardPricingProvider
+
+        config_option :default_gl_accounts, {
+            # The Accounts Receivable (AR) GL account number to use for freshly created Customers
+            ar: '1200',
+            # The Accounts Payable (AP) GL account number to use for freshly created Vendors
+            ap: '2200',
+            # The Freight GL account number to use for freshly created Vendors
+            freight: '6420',
+            # The Asset GL account number to use for freshly created SKUs
+            asset: '1100',
+            # Clearing account for inventory that's been
+            inventory_receipts_clearing: '2600',
+            # Holding account for funds that are awaiting deposit
+            deposit_holding: '1010'
+        }
+    end
+
+
+
+    class << self
+        @@config = Configuration.new
+        def config
+            @@config
+        end
+
+        def configure
+            yield(@@config)
+        end
+    end
+
+
+
+end

data/lib/skr/db/migration_helpers.rb

@@ -0,0 +1,178 @@
+require 'lanes/configuration'
+
+module Skr
+
+    module DB
+
+        module TableFields
+
+            def skr_code_identifier
+                column( :code, :string,  :null=>false )
+                skr_extra_indexes['code'] = {}
+            end
+
+            def skr_visible_id
+                column( :visible_id, :integer,  :null=>false )
+                skr_extra_indexes['visible_id'] = {
+                    function: 'CAST(visible_id AS VARCHAR)'
+                }
+            end
+
+            # track modifications
+            def skr_track_modifications( create_only: false )
+                column( :created_at, :datetime,   :null=>false )
+                column( :created_by_id, :integer, :null=>false )
+                unless create_only
+                    column( :updated_at, :datetime,   :null=>false )
+                    column( :updated_by_id, :integer, :null=>false )
+                end
+            end
+
+            def skr_currency( names, options )
+                options[ :precision ] ||= 15
+                options[ :scale ]     ||= 2
+                column( names, :decimal, options )
+            end
+
+            # An skr_reference combines a belongs_to / has_one column
+            # with a postgresql foreign key reference.
+            def skr_reference( to_table, *args )
+                options = args.extract_options!
+
+                options[:column] ||= to_table.to_s + '_id'
+
+                column( options[:column], :integer, :null=>options[:null] || false )
+                to_table = options[:to_table] if options.has_key? :to_table
+
+                if options[:single]
+                    to_table = to_table.to_s.pluralize
+                end
+                skr_foreign_keys[ to_table.to_sym ] = options
+            end
+
+            def skr_foreign_keys
+                @skr_foreign_keys ||= {}
+            end
+
+            def skr_extra_indexes
+                @skr_extra_indexs ||= {}
+            end
+        end
+
+        module MigrationMethods
+
+            def create_skr_table(table_name, *args, &block)
+                definition = nil
+                create_table( Skr.config.table_prefix + table_name, *args ) do | td |
+                    # Thanks for the trick from the Foreigner gem!
+                    # in connection_adapters/abstract/schema_statements
+                    definition = td
+                    block.call(td) unless block.nil?
+                end
+                definition.skr_foreign_keys.each do |to_table, options |
+                    skr_add_foreign_key( table_name, to_table, options )
+                end
+                definition.skr_extra_indexes.each do | index_column, options |
+                    skr_add_index( table_name, index_column, options )
+                end
+            end
+
+            def skr_add_index( table_name, columns, options={} )
+                table_name = Skr.config.table_prefix + table_name.to_s
+                if options[:function]
+                    unique = options[:unique] ? 'unique' : ''
+                    name   = table_name + 'indx_' + columns
+                    execute( "create #{unique} index #{name} on #{table_name}(#{options[:function]})" )
+                else
+                    add_index( table_name, columns, options  )
+                end
+            end
+
+            def skr_add_foreign_key( table_name, to_table, options = {} )
+                from_table = Skr.config.table_prefix + table_name.to_s
+                to_table   = Skr.config.table_prefix + to_table.to_s
+
+                column  = options[:column] || "#{to_table.to_s.singularize}_id"
+                foreign_key_name = options.key?(:name) ? options[:name].to_s : "#{from_table}_#{column}_fk"
+
+                primary_key = options[:primary_key] || "id"
+                dependency = case options[:dependent]
+                             when :nullify then "ON DELETE SET NULL"
+                             when :delete  then "ON DELETE CASCADE"
+                             when :restrict then "ON DELETE RESTRICT"
+                             else ""
+                             end
+                sql = "ALTER TABLE #{quote_table_name(from_table)} " +
+                "ADD CONSTRAINT #{quote_column_name(foreign_key_name)} " +
+                "FOREIGN KEY (#{quote_column_name(column)}) " +
+                "REFERENCES #{quote_table_name( to_table )}(#{primary_key})"
+                sql << " #{dependency}" if dependency.present?
+                sql << " #{options[:options]}" if options[:options]
+
+                execute(sql)
+            end
+
+            def drop_skr_table( table_name, *args )
+                drop_table( Skr.config.table_prefix + table_name )
+            end
+
+            def remove_skr_index( table_name, column )
+                remove_index( Skr.config.table_prefix + table_name, column )
+            end
+
+        end
+
+        module CommandRecorder
+            def create_skr_table(*args)
+                record(:create_skr_table, args)
+            end
+
+            def drop_skr_table(*args)
+                record(:drop_skr_table, args)
+            end
+
+            def invert_create_skr_table(args)
+                from_table, to_table, add_options = *args
+                add_options ||= {}
+                if add_options[:name]
+                    options = {name: add_options[:name]}
+                elsif add_options[:column]
+                    options = {column: add_options[:column]}
+                else
+                    options = to_table
+                end
+                [:drop_skr_table, [from_table, options]]
+            end
+
+            def skr_add_index(*args)
+                record(:skr_add_index,args)
+            end
+            def invert_skr_add_index(args)
+                table, column = *args
+                [:remove_skr_index, [table, column]]
+            end
+
+        end
+
+    end
+
+end
+
+
+class ActiveRecord::Migration
+    def skr_prefix
+        Skr.config.table_prefix
+    end
+end
+
+ActiveRecord::Migration::CommandRecorder.class_eval do
+    include Skr::DB::CommandRecorder
+end
+
+ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+    include Skr::DB::MigrationMethods
+end
+
+ActiveRecord::ConnectionAdapters::TableDefinition.class_eval do
+    include Skr::DB::TableFields
+end

data/lib/skr/extension.rb

@@ -0,0 +1,23 @@
+require 'lanes/access/extension'
+
+module Skr
+
+    class Extension < Lanes::Extensions::Definition
+
+        identifier "skr"
+        self.uses_pub_sub = true
+        root_path Pathname.new(__FILE__).dirname.join("..","..").expand_path
+        components "record-finder", "select-field"
+
+        def on_boot
+            Lanes::API::Root.before do
+                Thread.current[:demo_user_info] = {
+                  name: session[:name],
+                  email: session[:email]
+                }
+            end
+        end
+
+    end
+
+end

data/lib/skr/model.rb

@@ -0,0 +1,19 @@
+module Skr
+
+    class Model < Lanes::Model
+        self.abstract_class = true
+
+        include Concerns::ActsAsUOM
+        include Concerns::StateMachine
+        include Concerns::HasSkuLocLines
+        include Concerns::HasGlTransaction
+        include Concerns::IsOrderLike
+        include Concerns::IsSkuLocLine
+        include Concerns::ImmutableModel
+        include Concerns::VisibleIdIdentifier
+        include Concerns::LockedFields
+        include Concerns::CodeIdentifier
+        include Concerns::RandomHashCode
+    end
+
+end

data/lib/skr/models/address.rb

@@ -0,0 +1,97 @@
+module Skr
+
+    # A postal address with optional email and phone number
+    # By default all fields may be left blank.
+    #
+    # Validations may be selectively enabled by using the #enable_validations method
+    class Address < Skr::Model
+
+        # @!attribute email
+        #   The email address to use
+
+        # @!attribute ensure_not_blank
+        #   Must the Address be filled out?  The {#blank?} method must return false
+        #   @return [Boolean]
+        # @!attribute validate_email
+        #   Will the email be validated to meet the {EmailValidator} requirements?
+        #   @return [Boolean]
+        # @!attribute validate_phone
+        #   Should the phone field be validated to be not blank?
+        #   @return [Boolean]
+        attr_accessor :ensure_not_blank, :validate_email, :validate_phone
+
+        validates  :name, :line1, :city, :state, :postal_code, :presence=>true, :if=>:ensure_not_blank
+        validates  :email, :presence=>true, :email=>true, :if=>:validate_email
+        validates  :phone, :presence=>true, :if=>:validate_phone
+       
+        # @return [Address] a blank copy of an address
+        def self.blank
+            Address.new({ name: '', line1: '', city: '', state: '', postal_code: '' })
+        end
+
+        # @return [String] the name and email formatted for inclusion in an email
+        def email_with_name
+            "#{name} <#{email}>"
+        end
+
+        # fill in missing fields from postal_code using the ZipCode lookup table
+        def fill_missing_from_zip
+            if ( self.postal_code.present? &&
+                 ( self.city.blank? || self.state.blank? ) &&
+                 zc = ZipCode.find_by_code( self.postal_code )
+               )
+                self.city  ||= zc.city
+                self.state ||= zc.state
+            end
+        end
+
+        # @return [Boolean] is any of (name line1 city state postal_code) blank?
+        def blank?
+            return !! %w{ name line1 city state postal_code }.detect{ |field| self[field].blank? }
+        end
+
+        # split the name on space
+        # @return [Hash]
+        #   * :first [String] Portion of name before first space
+        #   * :last  [String] Portion of name after last space
+        def seperated_name
+            {:first=>name.to_s.split(' ').first, :last=> name.to_s.split(' ').last }
+        end
+
+        # enable selected validations
+        # @option options [Boolean] :include_email should the email be validated
+        # @option options [Boolean] :include_phone should the phone number be validated
+        def enable_validations( options = {} )
+            self.ensure_not_blank = true
+            self.validate_email = options[:include_email]
+            self.validate_phone = options[:include_phone]
+        end
+
+        # @param include [Array] list of extra fields to include in the address
+        # @return [String] Address converted to string, formatted with line breaks in the typical US style of display
+        # @example
+        #     address = Address.new( name: 'Bob\s Uncle',phone: '877-555-5555', line1: 'PO Box 87',
+        #                            city: 'Nowhereville', state: 'Urgandishly' postal_code: 'ASCN 1ZZ' )
+        #     address.to_s( :include => :phone ) #=>
+        #             Bob's Uncle
+        #             PO Box 87
+        #             Nowhereville, Urgandishly ASCN 1ZZ
+        #             877-5550-5555
+        def to_s( include: [] )
+            ret = ""
+            %w{ name line1 line2 }.each{ |a| ret << self[a] + "\n" unless self[a].blank? }
+            ret << city.to_s
+            ret << ' ' + state unless state.blank?
+            ret << ', ' + postal_code.to_s unless postal_code.blank?
+            include = [ *include ]
+            if include.any?
+                ret << "\n" + include.map{ | field | self[ field ] }.join(' ')
+            end
+            ret
+        end
+
+
+    end
+
+
+end # end Skr module