opensteam 0.9.0

data/generators/opensteam_property/templates/controllers/property_controller.rb

@@ -0,0 +1,86 @@
+class Administration::<%= class_name.pluralize %>Controller < AdministrationController
+  
+  # GET /<%= table_name %>
+  # GET /<%= table_name %>.xml
+  def index
+  	@<%= table_name %> = <%= class_name %>.find(:all)
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.xml  { render :xml => @<%= table_name %> }
+    end
+  end
+
+  # GET /<%= table_name %>/1
+  # GET /<%= table_name %>/1.xml
+  def show
+    @<%= file_name %> = <%= class_name %>.find(params[:id])
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.xml  { render :xml => @<%= file_name %> }
+    end
+  end
+
+  # GET /<%= table_name %>/new
+  # GET /<%= table_name %>/new.xml
+  def new
+    @<%= file_name %> = <%= class_name %>.new
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.xml  { render :xml => @<%= file_name %> }
+    end
+  end
+
+  # GET /<%= table_name %>/1/edit
+  def edit
+    @<%= file_name %> = <%= class_name %>.find(params[:id])
+  end
+
+  # POST /<%= table_name %>
+  # POST /<%= table_name %>.xml
+  def create
+    @<%= file_name %> = <%= class_name %>.new(params[:<%= file_name %>])
+
+    respond_to do |format|
+      if @<%= file_name %>.save
+        flash[:notice] = '<%= class_name %> was successfully created.'
+        format.html { redirect_to([:administration, @<%= file_name %>]) }
+        format.xml  { render :xml => @<%= file_name %>, :status => :created, :location => @<%= file_name %> }
+      else
+        format.html { render :action => "new" }
+        format.xml  { render :xml => @<%= file_name %>.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /<%= table_name %>/1
+  # PUT /<%= table_name %>/1.xml
+  def update
+    @<%= file_name %> = <%= class_name %>.find(params[:id])
+
+    respond_to do |format|
+      if @<%= file_name %>.update_attributes(params[:<%= file_name %>])
+        flash[:notice] = '<%= class_name %> was successfully updated.'
+        format.html { redirect_to([:administration, @<%= file_name %>]) }
+        format.xml  { head :ok }
+      else
+        format.html { render :action => "edit" }
+        format.xml  { render :xml => @<%= file_name %>.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /<%= table_name %>/1
+  # DELETE /<%= table_name %>/1.xml
+  def destroy
+    @<%= file_name %> = <%= class_name %>.find(params[:id])
+    @<%= file_name %>.destroy
+
+    respond_to do |format|
+      format.html { redirect_to(administration_<%= table_name %>_url) }
+      format.xml  { head :ok }
+    end
+  end
+end

data/generators/opensteam_property/templates/migration.rb

@@ -0,0 +1,14 @@
+class <%= migration_name %> < ActiveRecord::Migration
+
+  def self.up
+<% for attribute in migration_attributes -%>
+    add_column :properties, :<%= attribute.name %>, :<%= attribute.type %>
+<% end %>
+  end
+
+  def self.down
+<% for attribute in migration_attributes -%>
+    remove_column :properties, :<%= attribute.name %>
+<% end %>
+  end
+end

data/generators/opensteam_property/templates/models/property.rb

@@ -0,0 +1,3 @@
+class <%= class_name %> < Opensteam::Base::PropertyBase
+
+end

data/generators/opensteam_property/templates/views/administration/edit.html.erb

@@ -0,0 +1,19 @@
+<h1>Editing <%= class_name %></h1>
+
+<%%= error_messages_for :<%= singular_name %> %>
+
+<%% form_for([:administration, @<%= singular_name %>]) do |f| %>
+<% for attribute in attributes -%>
+  <p>
+    <b><%= attribute.column.human_name %></b><br />
+    <%%= f.<%= attribute.field_type %> :<%= attribute.name %> %>
+  </p>
+
+<% end -%>
+  <p>
+    <%%= f.submit "Update" %>
+  </p>
+<%% end %>
+
+<%%= link_to 'Show', [:administration, @<%= singular_name %>] %> |
+<%%= link_to 'Back', administration_<%= plural_name %>_path %>

data/generators/opensteam_property/templates/views/administration/index.html.erb

@@ -0,0 +1,24 @@
+<h1>Listing <%= plural_name %></h1>
+
+<table>
+  <tr>
+<% for attribute in attributes -%>
+    <th><%= attribute.column.human_name %></th>
+<% end -%>
+  </tr>
+
+<%% for <%= singular_name %> in @<%= plural_name %> %>
+  <tr>
+<% for attribute in attributes -%>
+    <td><%%=h <%= singular_name %>.<%= attribute.name %> %></td>
+<% end -%>
+    <td><%%= link_to 'Show', [:administration, <%= singular_name %>] %></td>
+    <td><%%= link_to 'Edit', edit_administration_<%= singular_name %>_path(<%= singular_name %>) %></td>
+    <td><%%= link_to 'Destroy', [:administration, <%= singular_name %>], :confirm => 'Are you sure?', :method => :delete %></td>
+  </tr>
+<%% end %>
+</table>
+
+<br />
+
+<%%= link_to 'New <%= singular_name %>', new_administration_<%= singular_name %>_path %>

data/generators/opensteam_property/templates/views/administration/new.html.erb

@@ -0,0 +1,18 @@
+<h1>New <%= singular_name %></h1>
+
+<%%= error_messages_for :<%= singular_name %> %>
+
+<%% form_for([:administration, @<%= singular_name %>]) do |f| %>
+<% for attribute in attributes -%>
+  <p>
+    <b><%= attribute.column.human_name %></b><br />
+    <%%= f.<%= attribute.field_type %> :<%= attribute.name %> %>
+  </p>
+
+<% end -%>
+  <p>
+    <%%= f.submit "Create" %>
+  </p>
+<%% end %>
+
+<%%= link_to 'Back', administration_<%= plural_name %>_path %>

data/generators/opensteam_property/templates/views/administration/show.html.erb

@@ -0,0 +1,10 @@
+<% for attribute in attributes -%>
+<p>
+  <b><%= attribute.column.human_name %>:</b>
+  <%%=h @<%= singular_name %>.<%= attribute.name %> %>
+</p>
+
+<% end -%>
+
+<%%= link_to 'Edit', edit_administration_<%= singular_name %>_path(@<%= singular_name %>) %> |
+<%%= link_to 'Back', administration_<%= plural_name %>_path %>

data/lib/opensteam.rb

@@ -0,0 +1,49 @@
+require 'active_record'
+
+module Opensteam #:nodoc:
+  
+  def self._logger(args) #:nodoc:
+    logger = ( defined? RAILS_DEFAULT_LOGGER) ? RAILS_DEFAULT_LOGGER :  Logger.new("#{RAILS_ROOT}/log/#{RAILS_ENV}.log")
+    logger.info "** [openSteam] #{args}"
+  end
+  
+
+  
+  
+  # load controller specific modules and the inventory_base modules
+  def self.load_opensteam_controller
+    require 'opensteam/user_base'
+    require 'opensteam/shopping_cart'
+    require 'opensteam/checkout'
+    require 'opensteam/inventory_base'
+  
+    Opensteam._logger "loaded!"
+  end
+  
+  
+end
+
+
+require 'opensteam/version'
+Opensteam._logger "v#{Opensteam::VERSION::STRING} loading .."
+
+require 'opensteam/config'
+require 'opensteam/finder'
+require 'opensteam/product_base'
+require 'opensteam/property_base'
+require 'opensteam/base'
+require 'opensteam/order_base'
+
+
+# extend ActiveRecord with the "opensteam" method
+ActiveRecord::Base.send(:include, Opensteam::Base::Extension )
+
+Dir.glob("#{RAILS_ROOT}/app/models/*.rb").collect { |f| require f }
+
+class Rails::Initializer #:nodoc:
+  def after_initialize_with_load_opensteam_controller
+    after_initialize_without_load_opensteam_controller
+    Opensteam.load_opensteam_controller
+  end
+  alias_method_chain :after_initialize, :load_opensteam_controller
+end

data/lib/opensteam/base.rb

@@ -0,0 +1,121 @@
+module Opensteam
+
+=begin rdoc
+Base Module for openSteam
+
+- Helper for ProductBase and PropertyBase
+- Extension Module for ProductBase associations
+- ActiveRecord Extension( Opensteam::Base::Extension::ActsOpensteam)
+- Abstract Class for OODesign (Opensteam::Base::ProductBase)
+- Base Class for Properties (STI)
+
+=end
+  module Base
+
+    # Extension for the Product-Inventory association
+    module ExistByPropertiesExtension
+      
+      # checks if an Inventory-Objects exists, which is associated with the given properties
+      def exist_by_properties?( p )
+        collect(&:properties).collect(&:sort).include?( p.kind_of?( Array ) ? p.sort : p )
+      end
+    end
+    
+    
+    # Extension for the Product-Properties association
+    module PropertiesExtension
+      def push( prop ) proxy_owner.send( :add_properties, Array(prop).flatten ) ; end 
+      alias :<< :push
+      def delete( prop ) proxy_owner.send( :del_properties, Array(prop).flatten ) ; end
+      def clear ; proxy_owner.send( :clear_properties ) ; end
+    end
+    
+
+    
+    
+=begin rdoc
+Helper Module for Opensteam Products and Properties
+
+Defines methods to determine wether an object is a property or a product.
+Included both in ProductBase and PropertyBase
+(Used for security reasons)
+=end
+    module Helper
+      
+      def self.included(base) #:nodoc:
+        base.extend(ClassMethods)
+        class << base ; attr_reader :opensteam_type ; end  
+      end
+      
+      def is_property?() self.class.is_property? ; end
+      def is_product?() self.class.is_product? ; end
+
+      
+      
+      module ClassMethods
+        def is_property?() self.ancestors.include? Opensteam::Base::PropertyBase ; end
+        def is_product?() ( self.opensteam_type || self.superclass.opensteam_type ) == :product ; end
+      end
+      
+    end
+
+    
+    module Extension #:nodoc:
+      
+      def self.included(base)
+        base.extend ActsOpensteam
+      end
+      
+      require 'opensteam/product_base'
+      require 'opensteam/property_base'
+      
+      # Extend ActiveRecord::Base with the opensteam method
+      module ActsOpensteam
+        
+        # called in a model to inject product-specific methods into the class:
+        #   
+        #   class Product < ActiveRecord::Base
+        #     opensteam :product
+        #   end
+        #
+        def opensteam(arg, *opt)
+          Opensteam._logger "including #{arg.to_s.humanize} Module in #{self.to_s} Model"
+          
+          if arg == :product
+            @opensteam_type = arg
+            class_eval { include Opensteam::ProductBase }
+          else
+            Opensteam._logger "opensteam-method #{arg.to_s} not suppored, in #{self.to_s}"
+          end
+
+        end
+      
+      end
+    
+    
+    end
+    
+   
+    
+    # Abstract ProductBase Class
+    # used for ObjectOriented Design
+    class ProductBase < ActiveRecord::Base
+      self.abstract_class = true
+      include Opensteam::ProductBase
+      @opensteam_type = :product
+      class << self ; attr_reader :opensteam_type ; end 
+    end
+    
+    
+
+    # Base Class for Properties (STI)
+    #
+    class PropertyBase < ActiveRecord::Base
+      include Opensteam::PropertyBase
+    end
+    
+    
+ 
+  end
+	
+end

data/lib/opensteam/checkout.rb

@@ -0,0 +1,89 @@
+require 'opensteam/shopping_cart'
+
+module Opensteam
+	
+  
+  
+=begin rdoc
+  Checkout Module
+
+  Defines methods to create a simple checkout-flow
+
+  Currently only used to define a :start action and a :finish action.
+  The rest of the checkout-process (the intermediate steps) are handled by the steps 
+  itself (like redirecting, errorhandling, etc)
+
+  TODO:
+  Implement an actual Checkout-Workflow Generator, with ErrorHandling etc
+
+=end
+  
+  module Checkout
+	
+
+    
+    class CheckoutFlowController < Opensteam::ShoppingCart::CartController
+			
+      before_filter :current_step
+
+      # save the current-action name in the sessions
+      def current_step
+        session[:current_action] = self.action_name
+      end
+			
+
+      # method to finish the checkout-process and redirect_to the action
+      # specified by :finish
+      def endstep
+        redirect_to_step(:finish)
+      end
+			
+			
+      # create the checkout flow
+      #
+      # define an init-method in your CheckoutController:
+      #      def init
+      #        create_checkout_flow do |c|
+      #          c.on :start, :intro
+      #          c.on :finish, :controller => "petstore", :action => "index"
+      #        end
+      #      end
+      def create_checkout_flow( target = self )
+        yield target if block_given?
+      end
+			
+			
+      # start the checkout process and redirect_to the action
+      # specified by :start
+      def invoke
+        redirect_to_step(:start)
+      end
+
+      
+      # define a flow step
+      #   on :start, :intro
+      #   on :finish, :controller => "webshop", :action => "index"
+      #
+      def on(sym, hash)
+        steps.store( sym, hash )
+      end
+			
+      private
+      def redirect_to_step(sym)
+      	if steps.fetch(sym).kind_of?(Hash)
+          redirect_to steps.fetch(sym)
+          return
+      	end
+      	
+      	redirect_to :action => steps.fetch(sym)
+      end
+      						
+      def steps()
+        @_steps ||= {}
+      end
+			
+    end
+		
+  end
+	
+end