stockor-core 0.2

data/lib/skr/concerns/has_sku_loc_lines.rb

@@ -0,0 +1,47 @@
+module Skr
+    module Concerns
+
+        module HasSkuLocLines
+
+            extend ActiveSupport::Concern
+
+            module InstanceMethods
+
+                def other_charge_lines
+                    self.lines.select{|l| l.sku.is_other_charge? }
+                end
+
+                def regular_lines
+                    self.lines.reject{|l| l.sku.is_other_charge? }
+                end
+
+                def regular_lines_total
+                    self.regular_lines.sum{|l|l.extended_price}
+                end
+
+                def subtotal
+                    self.regular_lines.inject(0){|sum,line| sum + line.extended_price }
+                end
+
+                def total
+                    if total = self.read_attribute('total')
+                        BigDecimal.new(total)
+                    elsif self.new_record? || self.association(:lines).loaded?
+                        self.lines.inject( BigDecimal.new('0') ){|sum,line| sum += line.extended_price }
+                    else
+                        BigDecimal.new( self.lines.sum('price*qty') )
+                    end
+                end
+            end
+
+            module ClassMethods
+
+                def has_sku_loc_lines
+                    self.send :include, InstanceMethods
+                    export_methods :total
+                end
+            end
+
+        end
+    end
+end

data/lib/skr/concerns/immutable_model.rb

@@ -0,0 +1,32 @@
+module Skr
+    module Concerns
+
+        module ImmutableModel
+
+            extend ActiveSupport::Concern
+
+            module ClassMethods
+
+                # Once it's created it may not be updated or destroyed.
+                # @raise [ActiveRecord::ReadOnlyRecord] if destroy, delete or save is called after it's been created.
+                def is_immutable(options = {})
+
+                    options[:except] = [*options[:except]].map{|name| name.to_s } # make sure except is present and an array
+
+                    before_destroy do
+                        raise ActiveRecord::ReadOnlyRecord.new( "Can not destroy #{self.class.model_name}, only create is allowed" )
+                    end
+
+                    before_update do
+                        unless ( changes.keys - change_tracking_fields - options[:except] ).blank?
+                            raise ActiveRecord::ReadOnlyRecord.new(  "Can not update, only create #{self.class.model_name}" )
+                        end
+                    end
+
+                end
+
+            end
+
+        end
+    end
+end

data/lib/skr/concerns/inv_extensions.rb

@@ -0,0 +1,24 @@
+module Skr
+    module Concerns
+
+        module INV
+
+            module Lines
+
+                def from_pick_ticket!
+                    proxy_association.owner.pick_ticket.lines.each do | line |
+                        build({ pt_line: line, qty: line.qty_to_ship })
+                    end
+                end
+
+                def from_sales_order!
+                    proxy_association.owner.sales_order.lines.each do | line |
+                        build({ so_line: line, qty: line.qty_allocated })
+                    end
+                end
+
+            end
+
+        end
+    end
+end

data/lib/skr/concerns/is_order_like.rb

@@ -0,0 +1,47 @@
+module Skr
+    module Concerns
+
+        module IsOrderLike
+            extend ActiveSupport::Concern
+
+            module InstanceMethods
+
+
+                # Set's the customer.  It also defaults the terms, addresses,and tax_exempt status to the customer's defaults
+                # @param cust [Customer]
+                # @return Customer
+                def customer=(cust)
+                    super
+                    self.terms ||= cust.terms
+                    self.is_tax_exempt    = cust.is_tax_exempt        if     self.is_tax_exempt.nil?
+                    self.billing_address  = cust.billing_address.dup  unless self.billing_address.present?
+                    self.shipping_address = cust.shipping_address.dup unless self.shipping_address.present?
+                end
+
+                protected
+
+                def set_order_defaults
+                    self.location ||= Location.default
+                    self.terms    ||= customer.terms if self.customer
+                    true
+                end
+
+            end
+
+            module ClassMethods
+
+                def is_order_like
+                    self.send :include, InstanceMethods
+                    has_sku_loc_lines # pull in the sku_loc_lines module
+
+                    validates_associated :lines
+
+                    before_validation :set_order_defaults, :on=>:create
+
+                end
+
+            end
+
+        end
+    end
+end

data/lib/skr/concerns/is_sku_loc_line.rb

@@ -0,0 +1,65 @@
+module Skr
+    module Concerns
+
+        module IsSkuLocLine
+
+            extend ActiveSupport::Concern
+
+            module InstanceMethods
+                def uom_record
+                    if self.association(:sku).loaded? && self.sku.association(:uoms).loaded?
+                        self.sku.uoms.detect{|uom| uom.code == self.uom_code }
+                    else
+                        self.sku.uoms.where({ code: self.uom_code }).first
+                    end
+                end
+
+                def ea_qty
+                    self.qty*self.uom_size
+                end
+
+                def is_other_charge?
+                    self.sku.is_other_charge?
+                end
+
+                def extended_price
+                    self.price && self.qty ? self.price * self.qty : BigDecimal.new(0)
+                end
+
+                private
+
+                def ensure_sku_does_not_change
+                    errors.add(:sku, "can not be updated") if changes['sku_code']
+                    if change = changes['sku_loc_id']
+                        # allow if the sku_id is the same on both old & new locations
+                        unless 1 == SkuLoc.where( id: change ).pluck('sku_id').uniq.length
+                            errors.add(:sku, "must be the same in both locations") if sku_code_changed?
+                        end
+                    end
+                end
+            end
+
+            module ClassMethods
+
+                def is_sku_loc_line( parent: nil )
+                    self.send :include, InstanceMethods
+
+                    validate  :ensure_sku_does_not_change, :on=>:update
+
+                    if parent
+                        before_create do
+                            self.position ||= ( self.send( parent ).lines.maximum(:position) || 0 ) + 1
+                        end
+                    end
+
+                    export_methods :extended_price, :optional=>false
+
+                end
+
+
+            end
+
+        end
+
+    end
+end

data/lib/skr/concerns/json_attribute_access.rb

@@ -0,0 +1,55 @@
+module Skr::Concerns
+
+    # @see ClassMethods
+    module JsonAttributeAccess
+
+        extend ActiveSupport::Concern
+
+        included do
+            class_attribute :blacklisted_json_attributes
+            class_attribute :whitelisted_json_attributes
+        end
+
+        module ClassMethods
+
+            # An attribute accessor that allows access from the API
+            def json_attr_accessor( *names )
+                names.each do | attr |
+                    attr_accessor attr
+                    whitelist_json_attributes attr
+                end
+            end
+
+            # @param attributes [Array of symbols] attributes that are safe for the API to set
+            def whitelist_json_attributes( *attributes )
+                options = attributes.extract_options!
+                self.whitelisted_json_attributes ||= {}
+                attributes.each{|attr| self.whitelisted_json_attributes[ attr.to_sym ] = options }
+            end
+
+            # @param attributes [Array of symbols] attributes that are not safe for the API to set
+            def blacklist_json_attributes( *attributes )
+                options = attributes.extract_options!
+                self.blacklisted_json_attributes ||= {}
+                attributes.each{|attr| self.blacklisted_json_attributes[ attr.to_sym ] = options }
+            end
+
+            # An attribute is allowed if it's white listed
+            # or it's a valid attribute and not black listed
+            # @param name [Symbol]
+            # @param user [UserProxy,User] who is performing request
+            def json_attribute_is_allowed?(name, user = Skr::UserProxy.current)
+                return false unless user.can_write?(self, name)
+                (self.whitelisted_json_attributes && self.whitelisted_json_attributes.has_key?( name.to_sym)) ||
+                    (
+                        self.attribute_names.include?( name.to_s ) &&
+                        ( self.blacklisted_json_attributes.nil? ||
+                          ! self.blacklisted_json_attributes.has_key?( name.to_sym )  )
+                    )
+            end
+
+        end
+
+    end
+
+end

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/pub_sub.rb

@@ -0,0 +1,105 @@
+module Skr::Concerns
+
+    module PendingEventListeners
+        # @private
+        @@listeners = Hash.new{ |hash, klass| hash[klass] = Hash.new{ |kh, event| kh[event]=Array.new } }
+        # @api private
+        def self.all
+            @@listeners
+        end
+    end
+
+
+    # Event subscription and publishing for Stockor Models
+    # Every model has certain built-in events (:save, :create, :update, :destroy)
+    # And may also implement custom events that reflect the models domain
+    # @example Send an email when a customer's name is updated
+    #   Customer.observe(:update) do |customer|
+    #       Mailer.notify_billing(customer).deliver if customer.name_changed?
+    #   end
+    # @example Update some stats when a Sku's qty is changed
+    #   Sku.observe(:qty_changed) do | sku, location, old_qty, new_qty |
+    #       Stats.refresh( location )
+    #   end
+    module PubSub
+        extend ActiveSupport::Concern
+
+        class InvalidEvent < RuntimeError
+        end
+
+        included do | base |
+
+            class_attribute :valid_event_names
+            class_attribute :_event_listeners
+            self.valid_event_names = [ :save, :create, :update, :destroy ]
+
+            after_save    :fire_after_save_events
+            after_create  :fire_after_create_events
+            after_update  :fire_after_update_events
+            after_destroy :fire_after_destroy_events
+        end
+
+        module ClassMethods
+            def inherited(base)
+                super
+                klass = base.to_s.demodulize
+                if PendingEventListeners.all.has_key?( klass )
+                    events = PendingEventListeners.all.delete(klass)
+                    events.each{ | name, procs | base.event_listeners[name] += procs  }
+                end
+            end
+
+            def event_listeners
+             self._event_listeners ||= Hash.new{ |hash, key| hash[key]=Array.new }
+            end
+
+            def _add_event_listener( name, proc )
+                self.event_listeners[name].push( proc ) unless self.event_listeners[name].include?(proc)
+            end
+
+            def observe( event, &block )
+                _ensure_validate_event( event )
+                _add_event_listener( event.to_sym, block )
+            end
+
+            def _ensure_validate_event(event)
+                unless self.valid_event_names.include?(event.to_sym)
+                    raise InvalidEvent.new("#{event} is not a valid event for #{self}")
+                end
+            end
+
+            protected
+
+            def has_additional_events( *names )
+                self.valid_event_names += names.map{ |name| name.to_sym }
+            end
+        end
+
+        protected
+        def fire_after_destroy_events
+            _fire_event(:update, self )
+        end
+        def fire_after_update_events
+            _fire_event(:update, self )
+        end
+        def fire_after_create_events
+            _fire_event(:create, self )
+        end
+        def fire_after_save_events
+            _fire_event( :save, self )
+        end
+
+        def fire_event( name, *arguments )
+            self.class._ensure_validate_event( name )
+            arguments.unshift( self )
+            _fire_event( name, *arguments )
+        end
+
+        private
+        def _fire_event( name, *arguments )
+            self.class.event_listeners[ name.to_sym ].each{ | block | block.call(*arguments) }
+            return true
+        end
+    end
+
+end