opensteam 0.9.0

data/lib/opensteam/property_base.rb

@@ -0,0 +1,63 @@
+module Opensteam
+  
+  
+=begin rdoc
+
+PropertyBase Module
+
+Defines all the Property-specific methods and variables.
+Used for the Property Base Class (STI)
+
+=end
+  
+  module PropertyBase
+  
+    module ClassMethods #:nodoc:
+
+      def table_name() "properties" ; end
+      
+      def properties
+        @properties ||= []
+      end
+      
+      # save all subclasses in the properties-variable
+      def inherited(property)
+        properties << property.to_s
+      end
+      
+    end
+  
+  
+    def self.included(base)
+      base.extend ClassMethods
+        
+      base.class_eval do
+        include Opensteam::Base::Helper
+        include Opensteam::Finder
+
+        has_many :inventories_properties,
+          :class_name => "Opensteam::InventoryBase::InventoriesProperty",
+          :foreign_key => "property_id"
+        
+        has_many :inventories, 
+          :class_name => "Opensteam::InventoryBase::Inventory",
+          :through => :inventories_properties
+        
+      end
+    end
+      
+      
+    def only_properties() #:nodoc:
+      is_property? ? self : nil
+    end
+      
+    # sort properties
+    def <=> (other) #:nodoc:
+      self.id <=> other.id
+    end
+
+  end
+  
+end
+  
+  

data/lib/opensteam/shopping_cart.rb

@@ -0,0 +1,343 @@
+
+require 'opensteam/finder'
+
+
+module Opensteam
+	
+  
+  module ShoppingCart
+		
+		
+		
+    # CartController
+    #
+    # - standard methods for ShoppingCart manipulation
+    # - automatically sets @cart to access shopping-cart
+    #
+    #
+    #
+    class CartController < ActionController::Base
+			
+			
+      #
+      #include @cart instance-variable in all actions
+      before_filter :set_instance_vars
+			
+      # 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
+      end
+			
+			
+      def get_cart
+        session[:cart] ||= Cart.new
+      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
+			
+      
+      # 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
+			
+      end
+			
+
+    end
+		
+		
+  end
+	
+end

data/lib/opensteam/user_base.rb

@@ -0,0 +1,165 @@
+module Opensteam
+	
+	
+  # UserBase
+  #
+  # Module for all User-Specific Classes
+  #
+  # 
+  module UserBase
+		
+    class Address < ActiveRecord::Base
+      belongs_to :customer
+      has_many :shipping_orders, :class_name => "Order", :foreign_key => "shipping_address_id"
+      has_many :payment_orders , :class_name => "Order", :foreign_key => "payment_address_id"
+		
+      validates_presence_of :city, :postal, :street, :land
+		
+			
+      # get all orders for current address
+      def orders
+        self.shipping_orders | self.payment_orders
+      end
+			
+    end
+
+		
+
+		
+    require 'digest/sha1'
+		
+		
+    class User < ActiveRecord::Base
+      has_many :addresses
+			
+      validates_length_of :login, :within => 3..20
+      validates_length_of :password, :within => 5..40
+      validates_presence_of :login, :email, :password, :password_confirmation, :salt
+      validates_uniqueness_of :email, :login
+      validates_confirmation_of :password
+      validates_format_of :email, :with => /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i, :message => "Invalid email" 
+		
+			
+      attr_protected :id, :salt, :type
+      attr_accessor :password, :password_confirmation
+			
+		
+      # authenticate
+      def self.authenticate(login,pass)
+        u = find(:first, :conditions => ["login = ?", login])
+        return nil if u.nil?
+        return u.login if Opensteam::UserBase::User.encrypt(pass, u.salt) == u.hashed_password
+        nil
+      end
+			
+		 
+      #set password
+      def password=(pass)
+        errors.add_to_base("password is empty") if pass.nil? or pass.empty?
+        @password = pass
+        self.salt = Opensteam::UserBase::User.random_string(10) if !self.salt?
+        self.hashed_password = Opensteam::UserBase::User.encrypt(@password, self.salt)
+      end
+			
+			
+      def is_admin?
+        return (self.class == Opensteam::UserBase::Admin ) ? true : false
+      end
+			
+			
+      protected
+      def self.random_string(len)
+        chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
+        newpass = ""
+        1.upto(len) { |i| newpass << chars[rand(chars.size-1)] }
+        return newpass
+      end
+			
+      def self.encrypt(pass, salt)
+        Digest::SHA1.hexdigest(pass+salt)
+      end
+			
+		
+    end
+				
+		
+    class Admin < User
+    end
+		
+		
+		
+    class Customer < ActiveRecord::Base
+      has_many :orders, :class_name => "Opensteam::OrderBase::Order"
+      has_many :addresses, :foreign_key => "user_id"
+			
+      validates_presence_of :email #, :firstname, :lastname
+      validates_format_of :email, :with => /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i, :message => "Invalid format .." 
+		
+    end
+		
+		
+		
+		
+		
+		
+		
+    # Opensteam::UserBase::Helper
+    #
+    # Helper Methods for a Controller
+    # used for before/after_fileter
+    #
+    #
+    module Helper
+		  
+			
+      # admin_required filter
+      def admin_required
+        if login = session[:user_login]
+          if Opensteam::UserBase::User.find(:first, :conditions => ["login = ?", login]).is_admin?
+            return true
+          end
+        end
+        flash[:error] = "you have to be an admin ..."
+        session[:return_to] = request.request_uri
+        redirect_to login_path
+        return false
+      end
+		  
+		  
+			
+      # user_required filter
+      def user_required
+        if login = session[:user_login]
+          if Opensteam::UserBase::User.find(:first, :conditions => ["login = ?", login])
+            return true
+          end
+        end
+        flash[:error] = "not logged in .."
+        session[:return_to] = request.request_uri
+        redirect_to login_path
+        return false
+      end
+		  
+			
+      # get the current authenticated user
+      def current_user
+        session[:user]
+      end
+		
+			
+			
+      # redirect to stored request
+      def redirect_to_stored
+        if return_to = session[:return_to]
+          session[:return_to] = nil
+          redirect_to return_to
+        else
+          redirect_to administration_path
+        end
+      end
+		  
+    end
+		
+  end
+	
+end