stockor-core 0.2

data/lib/skr/concerns/queries.rb

@@ -0,0 +1,20 @@
+module Skr
+    module Concerns
+
+        # A collection of handly utility methods to generate queries
+        module Queries
+
+            extend ActiveSupport::Concern
+
+            module ClassMethods
+
+                def compose_query_using_detail_view( view: view, join_to: join_to )
+                    view = Skr::Core.config.table_prefix + view.to_s
+                    joins("join #{view} as details on details.#{join_to} = #{table_name}.#{primary_key}")
+                    .select("#{table_name}.*, details.*")
+                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::Core::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 ] = Skr::Core::Strings.random( length ) if self[ field_name ].blank?
+                    end
+
+                end
+            end
+
+        end
+
+    end
+
+end

data/lib/skr/concerns/sanitize_json.rb

@@ -0,0 +1,49 @@
+module Skr
+    module Concerns
+
+        module SanitizeJson
+            extend ActiveSupport::Concern
+
+            # SanitizeJson is where all the exports_XXX concerns come together.  It's responsible for only allowing
+            # associations and other data to be saved that have been marked as safe.
+            module ClassMethods
+
+                # Takes in a hash containing attribute name/value pairs, as well as sub hashes/arrays.
+                # It returns only the attributes that have been marked as exportable
+                # @param json [Hash]
+                # @param user [UserProxy,User] who is performing request
+                def sanitize_json(json, user = Skr::UserProxy.current)
+                    return {} unless user.can_write?(self)
+                    json.each_with_object(Hash.new) do | kv, result |
+                        ( key, value ) = kv
+
+                        if json_attribute_is_allowed?( key.to_sym, user )
+                            result[ key ] = value
+                        else
+                            # allow nested params to be specified using Rails _attributes
+                            name = key.to_s.gsub(/_attributes$/,'')
+
+                            next unless has_exported_nested_attribute?( name, user )
+
+                            klass_name = self.reflections[ name.to_sym ].class_name
+                            klass = klass_name.safe_constantize || "Skr::#{klass_name}".constantize
+
+                            # only Hash, Array & nil is valid for nesting attributes
+                            cleaned = case value
+                                      when Hash  then klass.sanitize_json( value, user )
+                                      when Array then value.map{ | nested | klass.sanitize_json( nested, user ) }
+                                      else
+                                          nil
+                                      end
+                            result[ (name + '_attributes').to_sym ] = cleaned unless cleaned.blank?
+                        end
+                    end
+                end
+
+            end
+
+        end
+
+    end
+
+end

data/lib/skr/concerns/sku_extensions.rb

@@ -0,0 +1,52 @@
+module Skr
+    module Concerns
+
+        module Sku
+
+            module Locations
+                # Attempt to find a {SkuLoc} record and create it if not found
+                def find_or_create_for( location )
+                    location_id = location.is_a?(Numeric) ? location : location.id
+                    for_location(location) || create!({ :location_id=>location_id })
+                end
+
+                def for_location( location )
+                    location_id = location.is_a?(Numeric) ? location : location.id
+                    detect{ |l| l.location_id==location_id }
+                end
+
+                def default
+                    loc_id = Location.default.id
+                    detect{ |sl| sl.location_id == loc_id }
+                end
+            end
+
+            module Vendors
+                def default
+                    vendid = self.proxy_association.owner.default_vendor_id
+                    detect{ |sv| sv.vendor_id == vendid }
+                end
+                def for_vendor( vendor )
+                    vendor_id = vendor.is_a?(Numeric) ? vendor : vendor.id
+                    detect{ |v| v.vendor_id==vendor_id }
+                end
+            end
+
+            module Uoms
+                def default
+                    code = self.proxy_association.owner.default_uom_code
+                    with_code( code )
+                end
+
+                # Return the uom with code.  Since the UOM's are probably already loaded
+                # for the SKU, it makes sense to search over the in-memory collection
+                # vs hitting the DB again.
+                def with_code( code )
+                    detect{|uom| uom.code == code }
+                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,62 @@
+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 )
+
+                    json_attr_accessor :state_event
+
+                    export_methods :valid_state_events, :optional=>false
+                    blacklist_json_attributes :state
+                    whitelist_json_attributes :state_event
+
+                    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/track_modifications.rb

@@ -0,0 +1,48 @@
+module Skr::Concerns
+
+    # Extends Rails updated_by and created_by timestamps to also track who created and updated the model.
+    # It reads the current user from UserProxy.current_id when saving and updating the record
+    # The class_name for the created_by and updated_by is set to {Skr::Core::Configuration#user_model}
+    module TrackModifications
+        extend ActiveSupport::Concern
+
+        included do
+            class_attribute :record_modifications, :instance_writer=>false
+            self.record_modifications = true
+
+            belongs_to :created_by, :class_name=>Skr::Core.config.user_model
+            belongs_to :updated_by, :class_name=>Skr::Core.config.user_model
+
+            self.blacklist_json_attributes :created_at, :updated_at, :created_by_id, :updated_by_id
+            before_update :record_update_modifications
+            before_create :record_create_modifications
+        end
+
+        private
+
+        def _record_user_to_column( column )
+            user_id = Skr::UserProxy.current_id ? Skr::UserProxy.current_id : 0
+            write_attribute( column, user_id ) if self.class.column_names.include?( column )
+        end
+
+        def record_create_modifications
+            if self.record_modifications
+                _record_user_to_column('updated_by_id')
+                _record_user_to_column('created_by_id')
+            end
+            true
+        end
+
+        def record_update_modifications
+            if self.record_modifications && should_record_timestamps?
+                _record_user_to_column('updated_by_id')
+            end
+            true
+        end
+
+        def change_tracking_fields
+            %w{updated_by_id created_by_id updated_at created_at}
+        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/core.rb

@@ -0,0 +1,30 @@
+require 'active_record'
+
+module Skr
+    module Core
+    end
+    module Concerns
+    end
+    module Validators
+    end
+end
+
+require_relative "core/version"
+require_relative "core/logger"
+require_relative "core/testing"
+require_relative "core/standard_pricing_provider"
+require_relative "core/configuration"
+if defined?(::Rails)
+    require_relative "core/rails_engine"
+end
+require_relative "core/db"
+require_relative "core/strings"
+require_relative "core/numbers"
+require_relative "concerns/all"
+require_relative "validators/all"
+require_relative "model"
+require_relative "user_proxy"
+require_relative "sequential_id"
+
+require 'require_all'
+require_rel '*.rb'

data/lib/skr/core/configuration.rb

@@ -0,0 +1,87 @@
+require_relative "../concerns/attr_accessor_with_default"
+require_relative "standard_pricing_provider"
+
+module Skr
+    module Core
+
+        class Configuration
+            include Skr::Concerns::AttrAccessorWithDefault
+            # Since changing a config value inadvertently
+            # can have pretty drastic consequences that might not be
+            # discovered immediately, we log each time a value is changed
+            def self.config_option( name, default )
+                define_method( "#{name}=" ) do | value |
+                    old_value = self.send( name )
+                    if old_value.is_a?(String) && Skr::Core.logger
+                        Skr::Core.logger.info "Config option #{name} changed from #{old_value} to #{value}"
+                    end
+                    instance_variable_set( "@#{name}", value )
+                end
+                attr_reader_with_default( name, default )
+            end
+        end
+
+        class DefaultConfiguration < Configuration
+
+            # Since the Configuration class is essentially a singleton,
+            # we don't care about AttrReaderWithDefault sharing values between instances
+            # Therefore all the values are given directly and not enclosed in Procs/lambdas.
+
+            # 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 :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'
+            }
+
+            config_option :pricing_provider, Skr::Core::StandardPricingProvider
+        end
+
+        class << self
+            @@config = DefaultConfiguration.new
+            def config
+                @@config
+            end
+
+            def configure
+                yield(@@config)
+            end
+        end
+
+    end
+end