opensteam 0.9.0 → 0.9.1

data/lib/opensteam/helper/configurable_table.rb

@@ -0,0 +1,228 @@
+module Opensteam
+  
+  module Helper
+    
+    
+    # ConfigurableTable
+    #
+    # Module to Configure, Search and Sort a table, depending on a model-collection
+    #
+    module ConfigurableTableController
+      
+      def self.included(base)
+        # base.extend( ClassMethods )
+        
+        base.class_eval do
+          include InstanceMethods
+          before_filter :set_sort_column
+          private :sort_model, :set_sort_column
+        end
+      end
+      
+      
+      module InstanceMethods
+      
+        # before_filter:
+        # if params[:sort] is set, it gets the current sort-column from the
+        # configured_table class variable
+        #
+        def set_sort_column
+          if params[:sort]
+            model = params[:model].demodulize.classify.constantize rescue nil
+            @sort_column = model.configured_table.get_column( params[:sort] ) || model.configured_table.default_sort
+          end
+        end
+      
+        def sort
+          if params[:sort]
+            self.class.to_s =~ /^(.+)Controller/
+            model = $1.demodulize.classify.constantize rescue nil
+            @result = sort_model( model, @sort_column )
+          end
+          render :action => :sort
+          
+        end
+      
+        # sort the current model by column
+        # finds all entries for current model (including all associations)
+        # sort entries either by "ORDER" SQL or by a ruby sort-block (depending on
+        # the configuration or wether the column is an association)
+        #
+        def sort_model( model, column, conditions = nil, includes = nil )
+          finder_args = {}
+          finder_args[:conditions] = conditions if conditions
+          finder_args[:include] = includes if includes
+          
+          if column.order_ruby?
+            result = model.find( :all, finder_args )
+            result.sort!(&column.order)
+          else
+            finder_args[:order] = column.order
+            result = model.find(:all, finder_args )
+          end
+          toggle_sorted( model.to_s.demodulize )
+          result.reverse! if sorted?( model.to_s.demodulize )
+          result
+        end
+        
+        # if model is currently sorted ascending
+        def sorted?(model)
+          session["#{model}_sorted".to_sym] ? true : false ;
+        end
+        
+        
+        # toggle the sorted-sesssion variable for the given model
+        def toggle_sorted(model)
+          session["#{model}_sorted".to_sym] = session["#{model}_sorted".to_sym] ? false : true
+        end
+      end
+    end
+    
+      
+
+
+    module ConfigurableTable
+      
+      def self.included(base)
+        base.extend(ClassMethods)
+        
+      end
+       
+
+      module ClassMethods
+        # configure a table
+        # takes a block, like:
+        #   configure_table :order do
+        #     column :id, :name => "ID"
+        #   end
+        #
+        def configure_table( mdl, &block )
+          mdl = mdl.to_s.classify.constantize unless mdl.is_a?( Class )
+
+
+          mdl.class_eval do
+            @configured_table = ConfigTable.new( self )
+            @configured_table.instance_eval( &block )
+            
+            class << self ; attr_accessor :configured_table ; end
+          end
+
+        end
+      end
+      
+      
+    
+      
+      
+      # ConfigTable
+      # Holds all the Columns defined fot the Configurable-Table
+      #
+      class ConfigTable
+        
+        attr_accessor :columns, :model, :assocs, :assoc_names, :table_id
+        
+        def initialize(mdl)
+          @columns = []
+          @model = mdl
+          @table_id = "#{@model.table_name}_configured_table"
+          @assocs = mdl.reflect_on_all_associations
+          @assoc_names = @assocs.collect(&:name)
+        end
+        
+        
+        def default_sort_col( id )
+          @default_sort = id.to_sym
+        end
+        
+        def column( id, *args )
+          @columns << Column.new( id.to_sym, self, *args )
+        end
+        
+        def get_column(id) 
+          @columns.find { |s| s.id.to_sym == id.to_sym }
+        end
+        
+        def default_sort ; get_column( @default_sort ) ; end
+        
+      end
+      
+      class Column
+        attr_accessor :id, :name, :opts, :order, :config_table, :method, :table_name, :sql_query
+        
+        
+        # initialize a column
+        # if column is an association of the current model, the entries
+        # are sorted either by a ruby-block (if a :method is defined to call on the
+        # association-object), by :size (ruby-block, if its a _has_many_ association) or
+        # simply by the id (ORDER-SQL statement)
+        # if columns is not an association, the entries are sorted by an ORDER-SQL statement.
+        #
+        def initialize( id, config_table, *args )
+          @id = id
+          @opts = *args || Hash.new(nil)
+          @method = @opts[:method]
+          @name = @opts[:name] || @id.to_s
+          @config_table = config_table
+          
+          @assoc = @config_table.assocs.find { |s| s.name.to_sym == @id.to_sym }
+          
+          @order = @opts[:sort]
+         
+          
+          
+          unless @order
+            if is_assoc?
+              if @method
+                @order = Proc.new { |a,b|
+                  a.__send__( @id ).__send__( @method ).to_s <=> b.__send__( @id ).__send__( @method ).to_s
+                }
+                # @order = "`#{assoc_table_name}`.`#{@method}`"
+              else
+                @order = is_has_many_assoc? ? Proc.new { |a,b| a.__send__(@method).size <=> b.__send__(@method).size } :
+                  "`#{assoc_table_name}`.`id`"
+              end
+            else
+              @order = "`#{@config_table.model.table_name}`.`#{@id}`"
+            end
+          end
+
+        end
+        
+        def sql_query
+          is_assoc? ? "`#{table_name}`.`#{@method =~ /size/ ? 'id' : @method}`" : 
+            "`#{table_name}`.`#{@id}`" ;
+        end
+        
+        def table_name
+          is_assoc? ? assoc_table_name : @config_table.model.table_name ;
+        end
+        
+        def is_assoc? #:nodoc:
+          @assoc ? true : false
+        end
+        
+        def is_has_many_assoc? #:nodoc:
+          @assoc.macro =~ /has_many/
+        end
+        
+        def assoc_table_name #:nodoc:
+          @assoc.options.include?( :class_name ) ?
+            @assoc.options[:class_name].constantize.table_name :
+            @id.to_s.tableize
+        end
+
+        
+        def order_ruby? #:nodoc:
+          @order.is_a?( Proc )
+        end
+      end
+        
+    end
+    
+  end
+      
+      
+      
+      
+      
+end

data/lib/opensteam/history.rb

@@ -0,0 +1,56 @@
+#	openSteam - http://www.opensteam.net
+#  Copyright (C) 2008  DiamondDogs Webconsulting
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; version 2 of the License.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along
+#  with this program; if not, write to the Free Software Foundation, Inc.,
+#  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+module Opensteam
+
+  
+  # History Module
+  #
+  # Defines all the History (Logging) specific class + modules
+  #
+  module History
+    
+    class Base < ActiveRecord::Base
+      self.table_name = "histories"
+      belongs_to :receiver, :polymorphic => true
+    end
+    
+   
+    def self.included(receiver)
+      receiver.class_eval do
+        include InstanceMethods
+      
+        has_many :history, :class_name => 'Opensteam::History::Base', :as => :receiver
+
+      end
+    end
+    
+    
+    
+    module InstanceMethods
+     
+      def add_history( message )
+        save
+        self.history.create( :message => message )
+      end
+      
+    end
+
+
+  end
+
+  
+end

data/lib/opensteam/initializer.rb

@@ -0,0 +1,127 @@
+#	openSteam - http://www.opensteam.net
+#  Copyright (C) 2008  DiamondDogs Webconsulting
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; version 2 of the License.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along
+#  with this program; if not, write to the Free Software Foundation, Inc.,
+#  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+module Opensteam
+  
+  class Initializer #:nodoc:
+    
+    class << self ;
+      def _logger(args)
+        logger = ( defined? RAILS_DEFAULT_LOGGER) ? RAILS_DEFAULT_LOGGER : Logger.new("#{RAILS_ROOT}/log/#{RAILS_ENV}.log")
+        logger.info "** [openSteam] #{args}"
+      end
+    
+    
+      def run( command = :process, config = Configuration.new )
+        yield config if block_given?
+    
+        init = new config
+        init.__send__( command )
+      end
+      
+      
+      def require_opensteam_after_initialize
+        require 'opensteam/user_base' ## AuthenticatedMethods include !!!
+
+        _logger "loaded!"
+      end
+      
+      
+    
+    end
+    
+
+    def initialize( c )
+      @config = c
+    end
+
+
+    def _logger(args) ; self.class._logger( args ) ; end
+
+    
+    def process
+      require 'opensteam/version'
+      _logger"v#{Opensteam::VERSION::STRING} loading .."      
+      
+      require_libs
+      
+      
+      # extend ActiveRecord with the "opensteam" method
+      ActiveRecord::Base.send(:include, Opensteam::Base::Extension )
+
+      Rails::Initializer.class_eval do
+        def after_initialize_with_opensteam_initialize
+          after_initialize_without_opensteam_initialize
+          
+          Opensteam::Initializer.require_opensteam_after_initialize
+          
+          Opensteam::ExtensionBase.init_extensions( :backend )
+          Opensteam::ExtensionBase.verify_extensions
+          
+        end
+      
+        alias_method_chain :after_initialize, :opensteam_initialize
+      end
+      
+    end
+    
+    
+    def require_libs
+      require 'opensteam/version'
+      require 'opensteam/config'
+      require 'opensteam/finder'
+      require 'opensteam/product_base'
+      require 'opensteam/property_base'
+      require 'opensteam/base'
+      require 'opensteam/history'
+      require 'opensteam/state_machine'
+      require 'opensteam/invoice_base'
+      require 'opensteam/shipment_base'
+      require 'opensteam/order_base'
+      require 'opensteam/state_logic'
+      require 'opensteam/extension_base'
+      require 'opensteam/shopping_cart'
+      require 'opensteam/cart_base'
+      require 'opensteam/checkout'
+      require 'opensteam/inventory_base'
+    
+    
+      require 'opensteam/helper/configurable_table'
+    
+    
+    end
+    
+  
+  end
+  
+  
+  
+  class Configuration
+    
+    def say_something
+    
+      puts "....."
+    
+    end
+  end
+  
+  
+  
+  
+  
+end
+
+

data/lib/opensteam/inventory_base.rb

@@ -1,3 +1,19 @@
+#	openSteam - http://www.opensteam.net
+#  Copyright (C) 2008  DiamondDogs Webconsulting
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; version 2 of the License.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along
+#  with this program; if not, write to the Free Software Foundation, Inc.,
+#  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
 module Opensteam
   
   
@@ -31,11 +47,18 @@ module Opensteam
       
       belongs_to :product, :polymorphic => true
       
-      has_many :inventories_properties
+      has_many :inventories_properties, :class_name => "Opensteam::InventoryBase::InventoriesProperty"
       has_many :properties, :through => :inventories_properties
       
       validates_presence_of :price, :storage
       
+      
+      def products
+        find(:all, :include => :product ).collect(&:product)
+      end
+      
+      
+      
      
 
       #  alias :real_properties :properties

data/lib/opensteam/invoice_base.rb

@@ -0,0 +1,61 @@
+#	openSteam - http://www.opensteam.net
+#  Copyright (C) 2008  DiamondDogs Webconsulting
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; version 2 of the License.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along
+#  with this program; if not, write to the Free Software Foundation, Inc.,
+#  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+module Opensteam
+
+
+  # Base Module for all Invoice-specific modules + classes
+  module InvoiceBase
+
+
+
+    # available States for an Invoice-Instance
+    module States
+
+    end
+
+
+
+
+    # Invoice Model
+    class Invoice < ActiveRecord::Base
+      include Opensteam::StateMachine
+      
+      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'
+      
+      
+      def initialize(*args)
+        super(*args)
+        if order
+          self.address = order.payment_address
+          self.customer = order.customer
+        end
+      end
+      
+      
+    end
+
+
+
+
+  end
+
+
+end

data/lib/opensteam/order_base.rb

@@ -1,3 +1,19 @@
+#	openSteam - http://www.opensteam.net
+#  Copyright (C) 2008  DiamondDogs Webconsulting
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; version 2 of the License.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along
+#  with this program; if not, write to the Free Software Foundation, Inc.,
+#  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
 module Opensteam
 	
 	
@@ -7,28 +23,100 @@ module Opensteam
   #
   #
   module OrderBase
-		
-		
-		
-    # Order Class
-    # 
-    #
+
+
+    module States
+
+    end
+
+    
+    module OrderExtension
+      def all_finished? ; empty? ? false : collect(&:finished?).all? ; end
+    end
+    
+    module OrderItemsExtension
+      def all_shipped? ; collect { |s| s.shipment != nil }.all? ; end
+      def all_invoiced? ; collect { |s| s.invoice != nil }.all? ; end
+    end
+
+    require 'uuidtools'
+    
+    
+    
+    # Order Model
     class Order < ActiveRecord::Base
-      belongs_to :customer, :class_name => 'Opensteam::UserBase::Customer'
-      has_many :order_items
+      include Opensteam::StateMachine
+
+      include Opensteam::UUIDHelper
+
+      # associations
+      
+      has_many :order_items, :class_name => 'Opensteam::OrderBase::OrderItem', :extend => OrderItemsExtension
+      
+      belongs_to :customer, :class_name => 'Opensteam::UserBase::User'
 			
       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
-			
-				
+	
+      has_many :invoices, :class_name => 'Opensteam::InvoiceBase::Invoice', :extend => OrderExtension
+      
+      has_many :shipments, :class_name => 'Opensteam::ShipmentBase::Shipment', :extend => OrderExtension
+      
+      #  belongs_to :payment_type
+      
+      # validations
+      validates_associated :customer, :payment_address, :shipping_address
+      
+      
+      alias :real_customer= :customer=
+      # find or initialize customer by email and associate it to the order
+      def customer= (cust)
+        
+        cust[:paassword] = cust[:password_confirmation] = "opensteam" unless cust[:password]
+        self.real_customer = Opensteam::UserBase::User.create( cust )
+        
+        
+        #        self.real_customer = Customer.find_or_initialize_by_email( cust[:email] )
+        #        
+        #        self.real_customer = Opensteam::UserBase::Customer.find_or_create_by_email( cust[:email] )
+        #        self.customer.update_attributes( { :firstname => cust[:firstname], :lastname => cust[:lastname] }  )
+      end
+      
+      
+      alias :real_payment_address= :payment_address=
+      # find or create payment-address and associate it with the order
+      def payment_address=(addr)
+        self.real_payment_address = get_address( addr )
+      end
+      
+      
+      alias :real_shipping_address= :shipping_address=
+      # find or create shipping-address and associate it with the order
+      def shipping_address=(addr)
+        self.real_shipping_address = get_address( addr )
+      end
+      
+      
+      
+      # copy the products from cart to order and update storage-quantity for inventory-entry
       def copy_from_cart( cart )
         cart.items.each do |v|
           li = OrderItem.new_item(v)
           order_items << li
+          li.inventory.storage -= li.quantity
+          li.inventory.save
         end
       end
+      
+      
+      private
+      def get_address(addr)
+        address = Opensteam::UserBase::Address.find( :first, :conditions => addr.update( { :user_id => self.customer.id } ) ) rescue nil
+        address = Opensteam::UserBase::Address.new( addr ) if address.nil?
+      end
+      
+
+      
     end
 	
 		
@@ -39,9 +127,12 @@ module Opensteam
     class OrderItem < ActiveRecord::Base
       belongs_to :order
       belongs_to :inventory , :class_name => "Opensteam::InventoryBase::Inventory"
+
+      belongs_to :invoice, :class_name => 'Opensteam::InvoiceBase::Invoice'
+      belongs_to :shipment, :class_name => 'Opensteam::ShipmentBase::Shipment'
+	
+      def is_available? ; true ; end
       
-			
-				
       def self.new_item(i)
         returning(self.new) do |li|
           li.itemid = i.yamlid