opensteam 0.9.2 → 0.9.3

data/lib/opensteam/order_base.rb

@@ -20,105 +20,172 @@ module Opensteam
   # OrderBase Module
   #
   # defines all Order specific Classes
-  #
-  #
   module OrderBase
 
-
-    module States
+  
+    # States Namespace
+    module States #:nodoc:
 
     end
 
     
     module OrderExtension
+      # checks if all items are finished (if state == :finished)
       def all_finished? ; empty? ? false : collect(&:finished?).all? ; end
     end
     
     module OrderItemsExtension
+      # checks if all items are shipped
       def all_shipped? ; collect { |s| s.shipment != nil }.all? ; end
+      
+      # checks if all items have an invoice
       def all_invoiced? ; collect { |s| s.invoice != nil }.all? ; end
     end
 
     require 'uuidtools'
     
-    
-    
     # Order Model
-    class Order < ActiveRecord::Base
+    class Order < Opensteam::Container::Base
       include Opensteam::StateMachine
-    #   include Opensteam::UUIDHelper
+      #   include Opensteam::UUIDHelper
+      
       
+      # order collection by given column (e.g. "containers.id" )
       named_scope :order_by, lambda { |by| { :include => Order.osteam_configtable.default_include, :order => Array(by).join(",") , :conditions => "users.id = users.id" } }
-      named_scope :by_user, lambda { |user_id| { :include => [:customer ], :conditions => { :customer_id => user_id } } }
       
-      # associations
+      # get orders by given user
+      named_scope :by_user, lambda { |user_id| { :include => [:customer ], :conditions => { :user_id => user_id } } }
       
-      has_many :order_items, :class_name => 'Opensteam::OrderBase::OrderItem', :extend => OrderItemsExtension
       
-      belongs_to :customer, :class_name => 'Opensteam::UserBase::User'
+      #== ASSOCIATIONS
+      has_many :items,
+        :class_name => "Opensteam::Container::Item",
+        :foreign_key => "container_id",
+        :extend => OrderItemsExtension
+      
+      belongs_to :customer,
+        :class_name => 'Opensteam::UserBase::User',
+        :foreign_key => 'user_id'
 			
-      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_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'
 	
-      has_many :invoices, :class_name => 'Opensteam::InvoiceBase::Invoice', :extend => OrderExtension
+      has_many :invoices,
+        :class_name => 'Opensteam::InvoiceBase::Invoice',
+        :extend => OrderExtension 
       
-      has_many :shipments, :class_name => 'Opensteam::ShipmentBase::Shipment', :extend => OrderExtension
+      has_many :shipments,
+        :class_name => 'Opensteam::ShipmentBase::Shipment',
+        :extend =>  OrderExtension
       
-      #  belongs_to :payment_type
+      has_many :payments,
+        :class_name => 'Opensteam::Payment::Base' ,
+        :extend => Opensteam::Payment::OrderExtension,
+        :dependent => :destroy
       
-      # validations
-      validates_associated :customer, :payment_address, :shipping_address
       
+      #== VALIDATIONS
+      validates_presence_of :payment_type, :shipping_type
+      validates_associated :customer, :shipping_address, :payment_address
+      validates_associated :payments
       
-      alias :real_customer= :customer=
-      # find or initialize customer by email and associate it to the order
-      def customer= (cust)
+      
+      
+      
+      
+      def self.per_page ; 3 ; end
+      
+      # override to_xml method
+      def to_xml( options = {} ) #:nodoc:
+        super options.merge( :root => "orders" )
+      end
+      
+      
+      # update the calculated tax of all items and the total_tax, total_price of the container (order)
+      def update_price_and_tax!
+        country = shipping_address ? shipping_address.country : Opensteam::Config::DEFAULT_COUNTRY
+          
+        items.each do |item|
+          item.update_attribute( :tax, item.calculate_tax( :country => country ) )
+        end
         
-        cust[:paassword] = cust[:password_confirmation] = "opensteam" unless cust[:password]
+        returning( self ) do |s|
+          s.total_price = items.collect(&:total_price).sum
+          s.total_tax = items.collect(&:tax).sum
+        end
+      end
+      
+      
+      
+      
+      alias :real_customer= :customer=
+      
+      def guest_customer=( cust )
+        cust[:password] = cust[:password_confirmation] = "opensteam" unless cust[:password]
+        cust[:profile] = "Guest"
         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
+
+
+      def existing_customer=(cust)
+        self.real_customer = Opensteam::UserBase::User.find( cust )
+      end
+      
       
       
       alias :real_payment_address= :payment_address=
       # find or create payment-address and associate it with the order
-      def payment_address=(addr)
+      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)
+      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
+      # DEPRECATED!!!
+#      def self.create_from_cart( cart )
+#        
+#        returning(create) do |order|
+#          cart.items.each do |v|
+#            v.container = order
+#            v.save
+#          end
+#        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?
+
+      # finds or initialize address
+      def get_address addr
+        Opensteam::UserBase::Address.find(:first, :conditions => addr ) ||
+          Opensteam::UserBase::Address.new( addr )
+      end
+      
+      # validates payment_type
+      # if payament_type == 'bogus', return true
+      def validate
+        return if self.payment_type == "bogus"
+        unless (p = Opensteam::Payment::Types.find_by_name( self.payment_type ) ) && p.active?
+          errors.add( :payment_type, "#{self.payment_type} currently not supported!")
+        end
       end
       
 
       
+      
     end
 	
 		
@@ -137,11 +204,18 @@ module Opensteam
       
       def self.new_item(i)
         returning(self.new) do |li|
-          li.itemid = i.yamlid
+          li.itemid = i.item.id
           li.quantity = i.quantity
-          li.inventory = i.inventory
+          li.inventory = i.item
+          li.price = i.price
         end
+        
       end
+      
+      
+
+      
+      
 			
     end
 			

data/lib/opensteam/payment.rb

@@ -0,0 +1,225 @@
+#	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
+  
+  
+  module Payment #:nodoc:
+
+    
+    # Default Extension for the PaymentTransaction Association in Opensteam::Payment::Base
+    #
+    # create a new payment_transaction object, yields the given block and save the response of the block
+    # in the current-transaction.
+    # The given block must return either a string (which is save in the transaction#message attribute) or
+    # an object with the following attributes/methods:
+    #   success?, authorization, message, params
+    #
+    # The PaymentTransaction Model is basically used to wrap the response of an ActiveMerchant Gateway.
+    # The first parameter for the block must be a gateway. (See ActiveMerchant#Gateways for more information.)
+    module PaymentTransactionExtension
+      def process *args 
+        
+        args = args.first if args.is_a? Array
+        
+        create do |t|
+          
+          t.action = args[:action]
+          t.amount = args[:amount]
+          
+          begin
+            response = yield t.payment.gateway
+            
+            if response.is_a? String
+              t.message = response
+              break
+            end
+            
+            t.success   = response.success? 
+            t.reference = response.authorization
+            t.message   = response.message
+            t.params    = response.params
+            t.test      = t.payment.gateway ? t.payment.gateway.test? : true
+            
+          rescue ActiveMerchant::ActiveMerchantError => e
+            t.success   = false
+            t.reference = nil
+            t.message   = e.message
+            t.params    = {}
+            t.test      = t.payment.gateway.test?
+            
+          end
+
+        end
+      
+      end
+    
+    end
+    
+    
+    # Association Extension for Order#Payment Association
+    module OrderExtension
+      
+      # create payment_object (according to proxy_owner.payment_type)
+      def create_payment( attr = {}, &block )
+        #     return unless proxy_owner.payment_type_valid?
+        proxy_target << Opensteam::Payment::Base[ proxy_owner.payment_type.to_sym].create( attr, &block )
+      end
+      
+      # build payment_object (according to proxy_owner.payment_type)
+      def build_payment( attr = {}, &block )
+        #     return unless proxy_owner.payment_type_valid?
+        proxy_target << Opensteam::Payment::Base[ proxy_owner.payment_type.to_sym ].new( attr, &block )
+      end
+
+      def all_captured?
+        empty? ? false : collect(&:payment_captured?).all? ;
+      end
+     
+    end
+    
+    
+    
+    class Types < ActiveRecord::Base
+      self.table_name = "payment_types"
+      
+      named_scope :active, { :conditions => { :active => true } }
+      validates_uniqueness_of :name
+      
+      def enable! ; self.update_attribute :active, true ; end
+      def disable! ; self.update_attribute :active, false ; end
+      def active? ; self.active ; end
+      def toggle! ; self.active? ? self.disable! : self.enable! ; end
+      
+      
+      class << self ;
+        
+        def register_payment_types!
+          
+          Opensteam::Payment::Base.payment_types.each do |p|
+            unless find_by_name( p.payment_id.to_s )
+              create( :name => p.payment_id.to_s, :active => false, :klass => p.to_s )
+            end
+          end
+          
+        end
+      end
+    end
+    
+    
+    # Base Class for all Payment Implementations
+    #
+    # 
+    class Base < ActiveRecord::Base
+      self.table_name = "payments"
+      
+      belongs_to :order, :class_name => 'Opensteam::OrderBase::Order'
+      
+      
+      has_many :transactions,
+        :class_name => 'Opensteam::Payment::PaymentTransaction',
+        :foreign_key => 'payment_id',
+        :extend => Opensteam::Payment::PaymentTransactionExtension,
+        :dependent => :destroy
+      
+
+
+      include Opensteam::StateMachine
+      
+      
+      cattr_accessor :payment_types
+      @@payment_types = []
+      
+      # the gateway class to use
+      class_inheritable_accessor :gateway_class
+      
+      # the gateway login
+      class_inheritable_accessor :gateway_user
+      
+      # the gateway password
+      class_inheritable_accessor :gateway_password
+      
+      class_inheritable_accessor :display_name
+      self.display_name = 'Payment Base Class'
+      
+      class_inheritable_accessor :display_description
+      self.display_description = 'Base Class for all Payment Implementations'
+      
+      class_inheritable_accessor :payment_id
+      self.payment_id = :base
+      
+      
+      class << self
+        
+        def inherited(sub) #:nodoc:
+          @@payment_types << sub
+        end
+        
+        # retrieve a payment-implementation class using the :payment_id
+        # Ex:
+        #   class CreditCardPayment < Opensteam::Payment::Base
+        #     self.payment_id = :credit_card
+        #   end
+        # 
+        #   Opensteam::Payment::Base[ :credit_card ] # => CreditCardPayment
+        #
+        def [](payment_id)
+          @@payment_types.find { |t| t.payment_id.to_sym == payment_id.to_sym }
+        end
+        
+        
+        
+        def new_with_type( *attr, &block )
+          if( h = attr.first).is_a? Hash and (type = h["type"] || h[:type] ) and ( klass = type.constantize ) != self
+            raise "#{klass} is not a subclass of #{self}" unless klass < self
+            return klass.new( *attr, &block )
+          end
+          new_without_type( *attr, &block )
+        end
+        alias_method_chain :new, :type
+        
+      end
+      
+      private
+      
+      # returns the current amount in cents
+      def amount_in_cents
+        ( amount * 100 ).to_i
+      end
+      
+      
+      
+      
+      
+      
+    end
+    
+
+    class PaymentTransaction < ActiveRecord::Base
+      belongs_to :payment, :class_name => 'Opensteam::Payment::Base'
+      serialize :params
+      
+      def action= a
+        self[:action] = a.to_s
+      end
+      
+    end
+    
+    
+  end
+  
+   
+end