opensteam 0.9.2 → 0.9.3

data/lib/opensteam/shipment_base.rb

@@ -25,6 +25,52 @@ module Opensteam
 
     end
 
+    
+    module ShippingCalculation
+      
+      def calculate_shipping_rate attr = {} 
+        send( "shipping_rate_#{Opensteam::Config[:shipping_strategy]}", attr )
+      end
+      
+      
+      def set_shipping_rate!
+        returning( self ) do |s|
+          s.shipping_rate = ( r = calculate_shipping_rate ).is_a?( Array ) ? r.sum : r
+          s.total_price += s.shipping_rate
+        end
+        #        self.update_attribute( :shipping_rate, ( r = calculate_shipping_rate ).is_a?( Array ) ? r.sum : r )
+      end
+      
+      
+      
+      def shipping_rate_per_order attr
+        set_shipping_attributes( attr )
+
+        ShippingRateGroup.find_by_name( attr[:group_name] ).rate_for( attr )
+      end
+      
+      
+
+      def shipping_rate_per_item attr
+        set_shipping_attributes( attr )
+        
+        self.items.collect { |i|
+          ShippingRateGroup.find_by_name( i.shipping_rate_group ).rate_for( attr ) rescue 0.0
+        }
+      end
+      
+      
+      def set_shipping_attributes( attr )
+        attr[:payment_type] = self.payment_type unless attr[:payment_type]
+        attr[:shipping_method] = self.shipping_type unless attr[:shipping_method]
+        attr[:country] = self.shipping_address.country unless attr[:country]
+        attr[:group_name] = Opensteam::Config[:shipping_rate_group_default] unless attr[:group_name]
+      end
+      
+      private :set_shipping_attributes
+      
+    end
+    
 
 
     # Shipment Model
@@ -35,13 +81,11 @@ module Opensteam
       belongs_to :order, :class_name => 'Opensteam::OrderBase::Order'
       belongs_to :customer, :class_name => 'Opensteam::UserBase::User'
       belongs_to :address, :class_name => 'Opensteam::UserBase::Address'
-
-      has_many :order_items, :class_name => 'Opensteam::OrderBase::OrderItem'
       
+      has_many :order_items, :class_name => 'Opensteam::Container::Item'
             
       named_scope :by_order, lambda { |order_id| { :include => :order, :conditions => { :order_id => order_id } } }
-      named_scope :order_by, lambda { |by| { :include => Shipment.osteam_configtable.default_include, :order => Array(by).join(",") , :conditions => "orders.id = orders.id" } }
-      
+      named_scope :order_by, lambda { |by| { :include => Shipment.osteam_configtable.default_include, :order => Array(by).join(",") , :conditions => "addresses.id = addresses.id" } }
       
       
       def initialize(*args)
@@ -51,16 +95,180 @@ module Opensteam
           self.address = order.shipping_address
           self.customer = order.customer
         end
-
       end
   
+
     end
+    
+    
+    # Model for Shipping Rate Groups
+    class ShippingRateGroup < ActiveRecord::Base
+      has_many :shipping_rates,
+        :class_name => 'Opensteam::ShipmentBase::RegionShippingRate',
+        :dependent => :destroy
+  
+      has_many :zones,
+        :through => :shipping_rates
+  
+      has_many :payment_additions,
+        :class_name => 'Opensteam::ShipmentBase::ShippingPaymentAddition'
+  
+
+      validates_presence_of :name
+      validates_uniqueness_of :name
+  
+      validates_associated :shipping_rates
+      validates_associated :payment_additions
+
+      after_update :save_shipping_rates, :save_payment_additions
+  
+  
+      def rate_for( attr = {} )
+        conditions = {}
+        conditions["zones.country_name"] = attr[:country] || Opensteam::Config[:default_country]
+        conditions["shipping_method"] = attr[:shipping_method] || Opensteam::Config[:shipping_method_default]
+    
+        srate = shipping_rates.find( :first, :include => :zone, :conditions => conditions )
+ 
+        rate = unless srate
+          shipping_disabled ? 0.0 : master_rate.to_f
+        else
+          srate.rate
+        end
+    
+        rate += get_payment_additions( attr[:payment_type] ) if attr[:payment_type]
+ 
+        rate
+      end
+  
+  
+  
+  
+  
+      private
+  
+      def get_payment_additions( payment_type )
+        if ( pa = payment_additions.find(:first, :conditions => { :payment_type => payment_type } ) )
+          pa.amount
+        else
+          0.0
+        end
+      end
+  
+  
 
+      def new_payment_additions=( pa )
+        pa.each do |r|
+          payment_additions.build( r )
+        end
+      end
+
+    
+      def existing_payment_additions=( pa )
+        payment_additions.reject(&:new_record?).each do |paddition|
+          attributes = pa[ paddition.id.to_s ]
+          if attributes
+            paddition.attributes = attributes
+          else
+            payment_additions.delete( paddition )
+          end
+        end
+      end
+  
+  
+      def new_rates=( rates )
+        rates.each do |r|
+          shipping_rates.build( r )
+        end
+      end
+  
+      def existing_rates=( rates )
+        shipping_rates.reject(&:new_record?).each do |rate|
+          attributes = rates[ rate.id.to_s ]
+          if attributes
+            rate.attributes = attributes
+          else
+            shipping_rates.delete( rate )
+          end
+        end
 
+      end
+  
+  
 
+      def validate
+        if shipping_rates.empty?
+          if self.master_rate.blank? && !self.shipping_disabled
+            errors.add_to_base( "Either add Shipping Rates or define a default rate!" )
+            errors.add( :shipping_rates, "Cannot be empty!" )
+            errors.add( :master_rate, "Cannot be empty!" )
+            errors.add( :shipping_disabled, "" )
+          end
+        end
+      end
 
+      def save_shipping_rates
+        shipping_rates.each { |s| s.save(false) }
+      end
+  
+      def save_payment_additions
+        payment_additions.each { |s| s.save(false) }
+      end
 
+  
+  
+    end
 
+    
+    # Model for ShippingRate depending on Region (Zone, Country, .. )
+    class RegionShippingRate < ActiveRecord::Base
+  
+      belongs_to :group,
+        :class_name => 'Opensteam::ShipmentBase::ShippingRateGroup'
+  
+      belongs_to :zone,
+        :class_name => 'Zone'
+  
+  
+      ## named scopes
+      
+      # find all by country-name and shipping-method-name
+      named_scope :by_country_and_shipping_method, lambda { |country, sm|
+        { :include => :zone,
+          :conditions => { "zones.country_name" => country, :shipping_method => sm }
+        }
+      }
+  
+      # find all by country-name
+      named_scope :by_country_name, lambda { |country_name|
+        { :include => :zone, :conditions => { "zones.country_name" => country_name } }
+      }
+  
+      # find all by shipping-method-name
+      named_scope :by_shipping_method, lambda { |shipping_method|
+        { :conditions => { :shipping_method => shipping_method } }
+      }
+  
+    end
+    
+    
+    
+    
+    # Model for ShippingRate Additions depending on the payment_type
+    class ShippingPaymentAddition < ActiveRecord::Base
+      self.table_name = "shipping_payment_additions"
+      
+      belongs_to :shipping_rate_group,
+        :class_name => "Opensteam::ShipmentBase::ShippingRateGroup"
+      
+      validates_uniqueness_of :payment_type, :scope => [ :shipping_rate_group_id ]
+      
+    end
+    
+    
+    
+    
+    
   end
 
-end
+end

data/lib/opensteam/shopping_cart.rb

@@ -19,7 +19,8 @@ require 'opensteam/finder'
 
 module Opensteam
 	
-  
+	
+  # Controller Actions for ShoppingCart( Opensteam::Container::Base, Opensteam::Cart ) manipulation
   module ShoppingCart
 		
 		
@@ -28,334 +29,53 @@ module Opensteam
       
       base.class_eval do
         include InstanceMethods
-        before_filter :set_instance_vars
-
-
+        before_filter :get_cart
       end
+
     end
     
-    module ClassMethods
+    module ClassMethods #:nodoc:
     end
     
     
     module InstanceMethods
     
-			
-      # delete item from cart
-      #
-      def del_item
-        get_cart.del( :cart_item_id => params[:id])
-        @current_item = params[:id]
-        redirect_to_index unless request.xhr?
-      end
-			
-			
-      # show item from cart
-      #
-      def show_cart_item
-        i = Opensteam::InventoryBase::Inventory.find( @cart.items[ params[:id].to_i ].yamlid )
-        @product = i.product
-        @inventory = [i]
-        @product.selected_inventory = @inventory
-        @properties = @product.selected_inventory.last.properties.to_h2 { |x| x.class.to_s.tableize }
-        @cart_details = true
-        render :action => :show
-      end
-		
-
-      
-      # add an inventory object to the shopping cart
-      #
-      # * finds the product + inventory object (based on selected properties)
-      # * checks if product is available
-      # * add inventory object to cart
-      def add_inventory_to_cart
-        if request.post?
-          
-          params[:product] = frmt params[:product]
-          
-          if params[:product][:properties] && params[:product][:properties].index("")
-            flash[:error] = "Please select a #{params[:product][:properties].index("").humanize}"
-            return
-          end
-          
-          product = Opensteam::Find.find_product_with_inventory( params[:product] )
-          if product.is_available?
-            unless @cart.add product.selected_inventories.last.id
-              render :update do |page| page.alert "Sorry, there are only #{product.selected_inventories.last.storage} available!" end
-            end
-          else
-            render :update do |page| page.alert "Sorry, this product is currently not available!" end
-          end
-        end
-      end
-      
-      
-			
-
-      def incr_quantity
-        if request.post?
-          ci = @cart.get( :cart_item_id => params[:id] )
-          unless ci.incr
-            render :update do |page| page.alert "Sorry, there are only #{ci.quantity} available!" end
-            return 
-          end
-        end
-        if session[:active_order]
-          render :template => "checkout/update_cart_content.rjs"
-        else
-          render :action => "add_inventory_to_cart.rjs"
-        end
-        
-      end
 
-			
-      def decr_quantity
-        if request.post?
-          ( ( ci = @cart.get( :cart_item_id => params[:id] ) ).quantity - 1 ) == 0 ?
-            @cart.items.delete_at( params[:id].to_i ) :
-            ci.decr ;
-        end
-        if session[:active_order]
-          render :template => "checkout/update_cart_content.rjs"
-        else
-          render :action => "add_inventory_to_cart.rjs"
-        end
-      end			
-			
-			
-			
-			
-      #
-      # update quantity for item in cart
-      #   params[:quantity] = { "item_id" => "quantity }
-      #
-      def update_quantity
-        if request.post?
-          params[:quantity].each { |key,value| @cart.set_quantity(key, value) }
-			
-          if session[:active_order]
-            redirect_to :action => "show_cart"
-            return
-          end
-        end
-        redirect_to_index
-      end
-			
-			
-			
-			
-      #
-      # empty cart
-      #
-      def empty_cart
-        wipe_cart
-        redirect_to_index
-      end			
-			
-			
-			
-		
-      #====================================================
-      # private methods
-      #
-      #
       private
-			
+      
       # format params[:product] hash (-> rescursive templates...)
       def frmt(h)
         returning(Hash.new) { |hash| h.each_pair { |k,v| k =~ /^products/ ? ( hash[:products] ||= [] ) << frmt(v) : hash[k] = v } }
       end
-						
 			
-      def set_instance_vars
-        @cart = get_cart
+      
+      def get_cart_id
+        session[:cart] ||= Opensteam::Container::Cart.create.id
       end
-			
-			
+      
       def get_cart
-        session[:cart] ||= Cart.new
+        @cart = Opensteam::Container::Cart.find( get_cart_id )
+      rescue
+        session[:cart] = Opensteam::Container::Cart.create.id
+        @cart = Opensteam::Container::Cart.find( session[:cart] )
       end
-			
+      
+		
       def wipe_cart
         session[:cart] = nil
         get_cart
       end
-			
-			
-      def redirect_to_index
-        redirect_to opensteam_index_path
-      end
-			
-			
-			
-      def get_user
-        if session[:user_login]
-          return Opensteam::UserBase::User.find(:first, :conditions => ["login = ?", session[:user_login]])
-        end
-      rescue
-        return nil
-      end			
 		
-			
-    end
-		
-		
-		
-    
-    class Cart
-			
-      ## cart_items
-      attr_accessor :items
-			
-			
-      # intialize items array
-      def initialize
-        @items = []
-      end
-			
-			
-
-      # get item from cart
-      #   get( :cart_itemd_id => 1 ) # get item by internal array id
-      #   get( :yamlid => 3 ) # get item by Inventory-id
-      #
-      def get( opts = {} )
-
-        if opts.has_key? :yamlid
-          @items.each do |v|
-            return v if v.yamlid == opts[:yamlid]
-          end
-					
-        elsif opts.has_key? :cart_item_id
-          return @items[ opts[:cart_item_id].to_i ]
-        end
-				
-        return nil
-		
-      end
-			
-			
-			
-      # add an item to cart or increment its quantity
-      def add( yamlid )
-        item = get( :yamlid => yamlid )
-        if item.nil?
-          @items << CartItem.new( yamlid )
-          return true
-        else
-          return item.incr
-        end
-      end
-			
-			
-			
-      # set quantity for item (by internal array-id)
-      def set_quantity( id, q )
-        item = @items[ id.to_i ]
-				
-        return nil if item.nil?
-				
-        q = q.to_i
-        if q == 0
-          @items.delete_at( id.to_i )
-        elsif q > 0
-          item.quantity = ( item.inventory.storage < q ) ? item.inventory.storage : q 
-        end
-				
-        item
-      end
-			
-			
-      # delete item from cart (:cart_item_id or :yamlid )
-      def del( opts = {} )
-        if opts.has_key?( :yamlid )
-          @items.delete( get( :yamlid => opts[:yamlid] ) )
-        elsif opts.has_key?( :cart_item_id )
-          @items.delete_at( opts[:cart_item_id].to_i )
-        end
-      end
-			
-					
-			
-      # calculate total price
-      def total_price
-        @items.collect { |x| x.price * x.quantity }.inject(&:+)
-      end
-			
-			
-			
-      protected
-			
-			
-			
-			
-    end
-		
-		
-		
-    class CartItem
-      include Opensteam::Finder
-			
-      @@_load_product_on_init = false
-      cattr_accessor :_load_product_on_init
-			
-      attr_reader :yamlid
-			
-      attr_reader :product
-			
-      attr_accessor :quantity
-			
-			
-			
-      #initialize cart-item
-      def initialize(id)
-        @yamlid = id
-        @quantity = 1
-      end
-			
-			
-			
-      # increase quantity
-      def incr
-        if (@quantity + 1 ) > inventory.storage
-          return false
-        else
-          @quantity += 1
-          return true
-        end
-      end
-			
-      # decrease quantity
-      def decr
-        @quantity -= 1
-      end
-			
-      # return product
-      def product
-        return Opensteam::InventoryBase::Inventory.find( @yamlid ).product
-      end
-			
+      alias :clear_cart :wipe_cart
       
-      # return Inventory Object
-      def inventory
-        return Opensteam::InventoryBase::Inventory.find( @yamlid )
-      end
       
-      # return price
-      def price
-        return Opensteam::InventoryBase::Inventory.find( @yamlid ).price
-      end
-				
-      private
-      def load_product_object
 			
+      def redirect_to_index
+        redirect_to opensteam_index_path
       end
 			
-
     end
-		
-		
+
   end
 	
 end