opensteam 0.9.0

data/lib/opensteam/config.rb

@@ -0,0 +1,31 @@
+module Opensteam
+  
+  
+  
+  # Config Module for Opensteam
+  #
+  #
+  module Config
+    
+    
+    PRODUCT_BASE_TABLE_PREFIX = :product
+    
+    module Errors
+      # generic error class
+      class OpensteamError < StandardError
+      end
+  
+      # NotAProduct Error
+      # raised if Object is not a product (make "constantize" secure..)
+      class NotAProduct < OpensteamError
+      end
+  
+      # NotAProperty
+      # raised if Object is not a property
+      class NotAProperty < OpensteamError
+      end
+  
+    end
+    
+  end
+end

data/lib/opensteam/finder.rb

@@ -0,0 +1,145 @@
+$:.unshift(File.dirname(__FILE__)) unless
+$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'opensteam/config'
+
+module Opensteam
+
+
+  # Finder Module
+  #
+  # 
+  module Finder
+    
+		
+    def self.included(base) #:nodoc:
+      base.extend(ClassMethods)
+    end
+		
+    module ClassMethods
+			
+    
+      # method is invoked before adding a product to the cart
+      #
+      # finds the product, specified in h and saves the inventory, based on the
+      # selected properties, in the "selected_inventory" var.
+      # 
+      # h is the params[:product] Hash,:
+      #   params[:product] = { :class => "ProductClass", :id => 1, 
+      #     :properties => { "Color" => 2, "Size" => 5 } 
+      #   }
+      #
+      def find_product_with_inventory( h )
+
+        product = find_product_by_id( h[:class], h[:id] )
+        props = h[:properties] ? h[:properties].collect { |x| find_property_by_id( x.first, x.last ) } : []
+        product.selected_inventory = product.inventories( props )
+        product
+        
+      end
+      
+      
+      # find all product tables (tables prefixed with Opensteam::Config::PRODUCT_BASE_TABLE_PREFIX)
+      # TODO : implement paginate for finder
+      def find_product_tables
+        find_tables("product")
+      end
+      
+      
+      # find all products
+      def find_products
+        find_product_tables.inject([]) { |r,v| r += v.classify.constantize.find(:all) }
+      end
+
+      
+      # find property tables
+      def find_property_tables
+        Opensteam::Base::PropertyBase.properties.collect(&:tableize)
+        #        find_tables("property")
+      end
+			
+      # find all properties
+      def find_properties
+        Properties.find(:all)
+#        find_property_tables.inject([]) { |r,v| r += v.classify.constantize.find(:all) }
+      end
+		
+      
+      # find all products of the specified Class
+      def find_product(klass)
+        contantize_pro(:product, klass).find(:all)
+      end
+      
+      # find a product specified by klass and id
+      def find_product_by_id(klass,id)
+        return nil if id.empty?
+        contantize_pro(:product,klass).find(id)
+      end
+      
+      # find all properties of the specified Class
+      def find_property(klass)
+        contantize_pro(:property,klass).find(:all)
+      end
+      
+      # find a property by klass and id
+      def find_property_by_id(klass,id)
+        return nil if id.empty?
+        contantize_pro(:property, klass).find(id)
+      end
+			
+      # checks if the "inventories_properties" table exists
+      def inventories_properties_exist?
+        not ActiveRecord::Base.connection.select_all("SHOW TABLES LIKE 'inventories_properties'").empty?
+      end
+			
+      # checks if the properties table exists
+      def properties_table_exists?
+        not ActiveRecord::Base.connection.select_all("SHOW TABLES LIKE 'properties'").empty?
+      end
+
+      
+						
+						
+			
+      # TODO implement STI support for products
+      private
+      
+  
+      def contantize_pro(s, klass ) #:nodoc:
+        if klass.classify.constantize.respond_to?("is_#{s.to_s}?") && klass.classify.constantize.send("is_#{s.to_s}?")
+          return klass.classify.constantize
+        else
+          raise Opensteam::Config::Errors::NotAProduct, "#{klass} is not a product, sorry .." if s == :product
+          raise Opensteam::Config::Errors::NotAProperty, "#{klass} is not a property, sorry .." if s == :property
+        end
+      end
+      
+      def find_tables(type) #:nodoc:
+        prefix = 
+          case type
+        when "property"
+          Opensteam::Config::PROPERTY_BASE_TABLE_PREFIX.to_s
+        when "product"
+          Opensteam::Config::PRODUCT_BASE_TABLE_PREFIX.to_s
+        end
+        tables = ActiveRecord::Base.connection.select_all("SHOW TABLES LIKE '#{prefix}\\_%'").collect(&:values).flatten.collect {
+          |t| t.gsub("#{prefix}_", "") }
+      end
+			
+			
+			
+			
+		
+    end #class methods
+		
+  end #Finder
+
+
+  # dummy class to access the finder-methods without including the model.
+  class Find
+    include Opensteam::Finder
+  end
+
+  
+  
+end #Opensteam

data/lib/opensteam/inventory_base.rb

@@ -0,0 +1,79 @@
+module Opensteam
+  
+  
+  
+=begin rdoc
+  InventoryBase Module
+
+  - defines the InventoriesProperty Join Model (joins Opensteam::InventoryBase::Inventory with Opensteam::Base::PropertyBase ).
+  - defins the Inventory Model
+  
+=end
+  module InventoryBase
+    
+    # Join Model for Inventory and ProductBase
+    class InventoriesProperty < ActiveRecord::Base
+      belongs_to :inventory, :class_name => "Opensteam::InventoryBase::Inventory"
+      belongs_to :property, :class_name => "Opensteam::Base::PropertyBase"
+
+      alias :real_property :property
+      def property() return !property_type ? real_property : property_type.constantize.find(:all) ; end
+
+    end
+    
+    
+    
+
+    # Inventory Model
+    class Inventory < ActiveRecord::Base
+      
+      has_many :order_items, :class_name => "Opensteam::OrderBase::OrderItem"
+      
+      belongs_to :product, :polymorphic => true
+      
+      has_many :inventories_properties
+      has_many :properties, :through => :inventories_properties
+      
+      validates_presence_of :price, :storage
+      
+     
+
+      #  alias :real_properties :properties
+      #  def properties
+      #    inventories_properties.collect(&:property).flatten
+      #  end
+  
+      
+      # define property accessor methods, like "Inventory.find(:first).colors"
+      def self.define_property_accessors
+        Opensteam::Base::PropertyBase.properties.each do |accessor| 
+          self.class_eval do
+            define_method( accessor.tableize ) { accessor.classify.constantize.find(:all) }
+          end
+        end
+      end
+  
+  
+      # check if inventory-object is active
+      def is_active?() active == 1 ; end
+      
+      # checks if inventory-object is available
+      def is_available?() storage > 0 && is_active? ; end
+  
+  
+    end
+    
+    
+  
+
+  end
+  
+  
+  
+  
+    
+    
+end
+  
+  
+  

data/lib/opensteam/order_base.rb

@@ -0,0 +1,58 @@
+module Opensteam
+	
+	
+  # OrderBase Module
+  #
+  # defines all Order specific Classes
+  #
+  #
+  module OrderBase
+		
+		
+		
+    # Order Class
+    # 
+    #
+    class Order < ActiveRecord::Base
+      belongs_to :customer, :class_name => 'Opensteam::UserBase::Customer'
+      has_many :order_items
+			
+      belongs_to :payment_address, :class_name => 'Opensteam::UserBase::Address', :foreign_key => 'payment_address_id'
+      belongs_to :shipping_address, :class_name => 'Opensteam::UserBase::Address', :foreign_key => 'shipping_address_id'
+			
+      belongs_to :payment_type
+			
+				
+      def copy_from_cart( cart )
+        cart.items.each do |v|
+          li = OrderItem.new_item(v)
+          order_items << li
+        end
+      end
+    end
+	
+		
+		
+    # OrderItem Class
+    #
+    #
+    class OrderItem < ActiveRecord::Base
+      belongs_to :order
+      belongs_to :inventory , :class_name => "Opensteam::InventoryBase::Inventory"
+      
+			
+				
+      def self.new_item(i)
+        returning(self.new) do |li|
+          li.itemid = i.yamlid
+          li.quantity = i.quantity
+          li.inventory = i.inventory
+        end
+      end
+			
+    end
+			
+  end
+	
+end
+

data/lib/opensteam/product_base.rb

@@ -0,0 +1,222 @@
+module Opensteam
+  
+=begin rdoc
+
+ProductBase Module
+
+Defines all the Product-specific methods and variables.
+Used to either be included into a model or injected with the 
+"opensteam :product" method.
+
+=end
+  
+  module ProductBase
+  
+
+    
+    module ClassMethods #:nodoc:
+      
+      
+      # define table_name and prefix
+      # all product-tables are prefixed with "product_"
+      def table_prefix() Opensteam::Config::PRODUCT_BASE_TABLE_PREFIX.to_s ; end
+      def table_name() self.table_prefix + "_" + self.to_s.tableize ; end
+      
+      def has_property(p = nil, opt = nil )
+        p ? ( self._has_property ||= {} ).store(p, opt) : ( self._has_property ||= {} )
+      end
+  
+      def has_product(p) (self._has_product ||= []) << p if p ; end
+      
+      
+      
+      # get all property-objects (records) for current product
+      # to define the properties the product is allowed to have use:
+      # - *has_property :property_class* in ProductModel
+      # default: all properties
+      #
+      def get_has_property
+        (self._has_property.nil? ? self.find_property_tables : self._has_property).inject({}) { |r,v|
+          r.merge!( { v => v.to_s.classify.constantize.find(:all) } ) unless v.first == :none } || {}
+      end
+	
+      # get all product-objects (records) for current product (used for bundle-products)
+      # to define the products the current bundle-product is allowed to have use:
+      # - *has_product :peoduct_model* in ProductModel
+      # default: no products
+      #
+      def get_has_products
+        products = (self._has_product || []).inject({}) { |r,v|
+          r.merge!( { v => v.to_s.classify.constantize.find(:all) } ) }  || {}
+
+        products.delete(self.to_s.tableize) #unless <%= class_name %>.self.referential
+
+        products
+      end
+      
+      
+    end
+  
+  
+  
+    def self.included(base)
+      base.extend ClassMethods
+
+      # call class-methods
+      base.class_eval do
+        
+        include Opensteam::Base::Helper
+        include Opensteam::Finder
+  
+        has_many :properties, :class_name => "Opensteam::Base::PropertyBase",
+          :finder_sql => 'SELECT properties.* FROM properties ' +
+          'INNER JOIN inventories_properties ON inventories_properties.property_id = properties.id ' +
+          'INNER JOIN inventories ON inventories.id = inventories_properties.inventory_id ' +
+          'WHERE (( inventories.product_type = "#{self.class}" ) AND ( inventories.product_id = #{id} ) ) ',
+          :extend => Opensteam::Base::PropertiesExtension,
+          :uniq => true
+
+
+        
+        # inventory association
+        has_many :inventories, :as => :product,
+          :extend => Opensteam::Base::ExistByPropertiesExtension,
+          :class_name => "Opensteam::InventoryBase::Inventory"
+                    
+  
+        # holds the properties the product is allowed to have
+        # used for view
+        class_inheritable_accessor :_has_property
+			
+        # holds the products the bundle-product is allowed to have
+        # used for view
+        class_inheritable_accessor :_has_product
+      
+        attr_accessor :selected_inventories
+
+        attr_accessor :property_errors
+        
+        alias_method :real_inventories, :inventories
+
+        def inventories( a = [] ) 
+          #puts "********* IIIIIIINNNNNVENTORRRIEEEEEEEESSS ***********  "
+          a.empty? ? real_inventories : real_inventories.collect { |x| (x.properties.sort - a.sort).empty? ? x : nil }.compact ;
+        end
+
+      end
+
+    end
+      
+      
+      
+    def selected_inventory() @selected_inventories ||= nil ; end
+    def selected_inventory=(i) @selected_inventories = i ; end 
+      
+    def property_errors() @property_errors ||= [] end
+    def property_errors=(a) @property_errors = a end
+
+    def is_available?
+      selected_inventories.last.active && selected_inventories.last.storage > 0
+    end
+    
+    def products ; [] ; end 
+      
+    # set property associations for the current product
+    # p can either be a hash or an array of properties.
+    #
+    #   p = [ PropertyA, PropertyB]
+    #   p = [ [ PropertyA, PropertyB], [ PropertyA, PropertyC] ]
+    #   
+    #   p = { "Size" => { "1" => 1 },
+    #         "Color" => { "32" => 1 } }
+    #
+    # for each property (or set of properties) an invenvory-object is created and associated
+    # with the properties.
+    #
+    # inventoy-objects which are currently associated with the product and do not
+    # match the properties (p) are deleted.
+    #
+    # used in the administration-views, to update the product-property associations.
+    #
+    def set_properties=(p)
+      save
+      
+      if p.empty? && properties.empty?
+        inventories << Opensteam::InventoryBase::Inventory.create( :price => 0, :storage => 0, :active => 0 )
+        return 
+      end
+      
+      if p.kind_of? Hash
+        prop = {}
+        p.each_pair { |k,v| prop[k] = v.collect { |x| k.classify.constantize.find( x.first ) } }
+        prop = prop.values.perm.collect(&:sort)
+      else
+        prop = p
+      end
+      
+      inventories.each do |i|
+        i.destroy unless prop.include? i.properties.sort
+      end
+
+      add_properties(prop)
+
+      save
+    end
+    
+    alias :properties= :set_properties=
+    
+    
+    # Add properties to the current product.
+    # For every property (or set of properties) an inventory-object is created (unless an inventory-object for the property (or set of properties) already exists).
+    def add_properties(prop)
+      prop.each do |pp|
+        unless inventories.exist_by_properties?( pp )
+          i = Opensteam::InventoryBase::Inventory.create( :price => 0, :storage => 0, :active => 0 )
+          i.properties << pp
+          inventories << i
+        end
+      end
+      
+    end
+    
+    
+    # delete properties from the current product
+    def del_properties(p)
+      return nil if p.empty?
+      return ( i = inventories( p ) ) ? i.collect(&:destroy) : nil ;
+    end
+
+    
+    # clear all properties for the current product
+    def clear_properties
+      inventories.collect(&:destroy)
+    end
+    
+
+      
+    # DEPRECATED !!!!!
+    # 
+    # 
+    # set products-association for object (virtual attributes)
+    # used for product-create/edit-view
+    # saves the product first, due to "unsaved associations" error
+    #
+    def set_products=(p)
+      save
+      products.delete_all
+      p.each_pair do |k,v|
+        v.each_pair { |id,n| products << k.classify.constantize.find(id) rescue nil }
+      end
+    end
+
+  end
+  
+  
+  
+  
+    
+    
+end
+  
+  
+