spree 0.9.4 → 0.10.0.beta

data/app/controllers/admin/shipping_rates_controller.rb

@@ -4,12 +4,13 @@ class Admin::ShippingRatesController < Admin::BaseController
 
   update.wants.html { redirect_to edit_object_url }
   create.wants.html { redirect_to edit_object_url }
+  destroy.success.wants.js { render_js_for_destroy }
     
   private 
   def build_object
     @object ||= end_of_association_chain.send((parent? ? :build : :new), object_params)
     @object.calculator = params[:tax_rate][:calculator_type].constantize.new if params[:tax_rate]
-    @object.calculator ||= ShippingRate.calculators.first.new
+    @object.calculator ||= ShippingRate.calculators.to_a.first.new
     @object
   end  
   def load_data

data/app/controllers/admin/states_controller.rb

@@ -23,4 +23,4 @@ class Admin::StatesController < Admin::BaseController
     def load_data
       @countries = Country.order_by_name
     end
-end
+end

data/app/controllers/admin/tax_categories_controller.rb

@@ -7,5 +7,7 @@ class Admin::TaxCategoriesController < Admin::BaseController
 
   update.response do |wants|
     wants.html { redirect_to collection_url }
-  end  
+  end
+  
+  destroy.success.wants.js { render_js_for_destroy }
 end

data/app/controllers/admin/tax_rates_controller.rb

@@ -3,15 +3,11 @@ class Admin::TaxRatesController < Admin::BaseController
   before_filter :load_data
                                                           
   create.success.wants.html { redirect_to collection_url }
-  update.success.wants.html { redirect_to collection_url }
+  update.success.wants.html { redirect_to collection_url }   
+  destroy.success.wants.js { render_js_for_destroy }
   
-  update.after do
-    Rails.cache.delete('vat_rates')
-  end
-
-  create.after do
-    Rails.cache.delete('vat_rates')
-  end
+  update.after :update_after
+  create.after :create_after
     
   private 
   def build_object
@@ -25,4 +21,12 @@ class Admin::TaxRatesController < Admin::BaseController
     @available_categories = TaxCategory.find :all, :order => :name
     @calculators = TaxRate.calculators
   end
+  
+  def update_after
+    Rails.cache.delete('vat_rates')
+  end
+  
+  def create_after
+    Rails.cache.delete('vat_rates')
+  end
 end

data/app/controllers/admin/taxonomies_controller.rb

@@ -4,23 +4,14 @@ class Admin::TaxonomiesController < Admin::BaseController
   create.wants.html {redirect_to edit_admin_taxonomy_url(@taxonomy)}
   update.wants.html {redirect_to collection_url}
   
-  create.after do
-    taxon = Taxon.new(:name => @taxonomy.name, :taxonomy_id => @taxonomy.id, :position => 1 )
-    taxon.save
-  end
-  
-  update.after do
-    taxon = @taxonomy.taxons.find_by_parent_id(nil)
-    taxon.name = @taxonomy.name
-    taxon.save
-  end
-  
   edit.response do |wants|
     wants.html
     wants.js do
       render :partial => 'edit.html.erb'
     end
   end
-
- 
+  
+  def get_children
+    @taxons = Taxon.find(params[:parent_id]).children
+  end
 end

data/app/controllers/admin/taxons_controller.rb

@@ -2,51 +2,24 @@ class Admin::TaxonsController < Admin::BaseController
   include Railslove::Plugins::FindByParam::SingletonMethods
   resource_controller
   before_filter :load_object, :only => [:selected, :available, :remove]
-  belongs_to :product
-  
+  before_filter :load_permalink_part, :only => :edit
+  belongs_to :product, :taxonomy
+
   create.wants.html {render :text => @taxon.id}
-  update.wants.html {render :text => @taxon.name}
+  update.wants.html {redirect_to edit_admin_taxonomy_url(@taxonomy)}
+  update.wants.json {render :json => @taxon.to_json()}
+
   destroy.wants.html {render :text => ""}
-  
-  create.before do 
-    @taxon.taxonomy_id = params[:taxonomy_id]
-  end
-  
-  update.before do
-    parent_id = params[:taxon][:parent_id]
-    position = params[:taxon][:position]
+  destroy.success.wants.js { render_js_for_destroy }
 
-    if parent_id || position #taxon is being moved
-      parent = parent_id.nil? ? @taxon.parent : Taxon.find(parent_id.to_i)
-      position = position.nil? ? -1 : position.to_i 
+  create.before :create_before
+  update.before :update_before
+  update.after :update_after
 
-      @taxon.move_to(parent, position)
-      if parent_id
-        @taxon.reload
-        @taxon.permalink = nil
-        @taxon.save!
-        @update_children = true
-      end
-    end
-    #check if we need to rename child taxons if parent name changes
-    @update_children = params[:taxon][:name] == @taxon.name ? false : true
-  end
-  
-  update.after do
-    #rename child taxons                  
-    if @update_children
-      @taxon.descendents.each do |taxon|
-        taxon.reload
-        taxon.permalink = nil
-        taxon.save!
-      end
-    end    
-  end
-
-  def selected 
+  def selected
     @taxons = @product.taxons
   end
-  
+
   def available
     if params[:q].blank?
       @available_taxons = []
@@ -60,14 +33,14 @@ class Admin::TaxonsController < Admin::BaseController
     end
 
   end
-  
+
   def remove
     @product.taxons.delete(@taxon)
     @product.save
     @taxons = @product.taxons
     render :layout => false
-  end  
-  
+  end
+
   def select
     @product = Product.find_by_param!(params[:product_id])
     taxon = Taxon.find(params[:id])
@@ -76,12 +49,79 @@ class Admin::TaxonsController < Admin::BaseController
     @taxons = @product.taxons
     render :layout => false
   end
-  
-  private 
+
+  private
+  def create_before
+    @taxon.taxonomy_id = params[:taxonomy_id]
+  end
+
+  def update_before
+    parent_id = params[:taxon][:parent_id]
+    new_position = params[:taxon][:position]
+
+    if parent_id || new_position #taxon is being moved
+      new_parent = parent_id.nil? ? @taxon.parent : Taxon.find(parent_id.to_i)
+      new_position = new_position.nil? ? -1 : new_position.to_i
+
+      # Bellow is a very complicated way of finding where in nested set we
+      # should actually move the taxon to achieve sane results,
+      # JS is giving us the desired position, which was awesome for previous setup,
+      # but now it's quite complicated to find where we should put it as we have
+      # to differenciate between moving to the same branch, up down and into
+      # first position.
+      new_siblings = new_parent.children
+      if new_position <= 0 && new_siblings.empty?
+        @taxon.move_to_child_of(new_parent)
+      elsif new_parent.id != @taxon.parent_id
+        if new_position == 0
+          @taxon.move_to_left_of(new_siblings.first)
+        else
+          @taxon.move_to_right_of(new_siblings[new_position-1])
+        end
+      elsif new_position < new_siblings.index(@taxon)
+        @taxon.move_to_left_of(new_siblings[new_position]) # we move up
+      else
+        @taxon.move_to_right_of(new_siblings[new_position]) # we move down
+      end
+      # Reset legacy position, if any extensions still rely on it
+      new_parent.children.reload.each{|t| t.update_attribute(:position, t.position)}
+
+      if parent_id
+        @taxon.reload
+        @taxon.set_permalink
+        @taxon.save!
+        @update_children = true
+      end
+    end
+
+    if params.key? "permalink_part"
+      parent_permalink = @taxon.permalink.split("/")[0...-1].join("/")
+      parent_permalink += "/" unless parent_permalink.blank?
+      params[:taxon][:permalink] = parent_permalink + params[:permalink_part]
+    end
+    #check if we need to rename child taxons if parent name or permalink changes
+    @update_children = true if params[:taxon][:name] != @taxon.name || params[:taxon][:permalink] != @taxon.permalink
+  end
+
+  def update_after
+    #rename child taxons
+    if @update_children
+      @taxon.descendents.each do |taxon|
+        taxon.reload
+        taxon.set_permalink
+        taxon.save!
+      end
+    end
+  end
+
   def reposition_taxons(taxons)
     taxons.each_with_index do |taxon, i|
-        taxon.position = i
-        taxon.save!
+      taxon.position = i
+      taxon.save!
     end
   end
+
+  def load_permalink_part
+    @permalink_part = object.permalink.split("/").last
+  end
 end

data/app/controllers/admin/trackers_controller.rb

@@ -0,0 +1,7 @@
+class Admin::TrackersController < Admin::BaseController
+  resource_controller
+
+  update.wants.html { redirect_to collection_url }
+  create.wants.html { redirect_to collection_url }
+    
+end

data/app/controllers/admin/users_controller.rb

@@ -1,39 +1,49 @@
 class Admin::UsersController < Admin::BaseController
-  resource_controller                                                             
-  before_filter :initialize_extension_partials
+  resource_controller
   before_filter :load_roles, :only => [:edit, :new, :update, :create]
-  
-  create.after do   
-    save_user_roles
-  end
 
-  update.before do
-    save_user_roles
+  create.after :save_user_roles
+  update.before :save_user_roles
+
+  index.response do |wants|
+    wants.html { render :action => :index }
+    wants.json { render :json => @collection.to_json(:include => {:bill_address => {:include => [:state, :country]}, :ship_address => {:include => [:state, :country]}}) }
   end
-                
+
   private
-  def collection   
-    @search = User.search(params[:search])
+  def collection
+    unless request.xhr?
+      @search = User.searchlogic(params[:search])
 
-    #set order by to default or form result
-    @search.order ||= "ascend_by_email"
+      #set order by to default or form result
+      @search.order ||= "ascend_by_email"
 
-    @collection_count = @search.count
-    @collection = @search.paginate(:per_page => Spree::Config[:admin_products_per_page],
-                                   :page     => params[:page])
+      @collection_count = @search.count
+      @collection = @search.paginate(:per_page => Spree::Config[:admin_products_per_page],
+                                     :page     => params[:page])
 
-    #scope = scope.conditions "lower(email) = ?", @filter.email.downcase unless @filter.email.blank?
+      #scope = scope.conditions "lower(email) = ?", @filter.email.downcase unless @filter.email.blank?
+    else
+      @collection = User.find(:all, :include => [
+                                  {:bill_address => [:state, :country]},
+                                  {:ship_address => [:state, :country]}],
+                          :conditions => ["users.email like :search
+                                            OR addresses.firstname like :search
+                                            OR addresses.lastname like :search
+                                            OR ship_addresses_users.firstname like :search
+                                            OR ship_addresses_users.lastname like :search", {:search => "%#{params[:q]}%"}])
+    end
   end
 
   def load_roles
     @roles = Role.all
   end
-  
+
   def save_user_roles
     return unless params[:user]
     @user.roles.delete_all
     params[:user][:role] ||= {}
-    params[:user][:role][:user] = 1     # all new accounts have user role 
+    params[:user][:role][:user] = 1     # all new accounts have user role
     Role.all.each { |role|
       @user.roles << role unless params[:user][:role][role.name].blank?
     }

data/app/controllers/admin/variants_controller.rb

@@ -6,11 +6,7 @@ class Admin::VariantsController < Admin::BaseController
     wants.html {render :action => :new, :layout => false}
   end
 
-  create.before do 
-    option_values = params[:new_variant]
-    option_values.each_value {|id| @object.option_values << OptionValue.find(id)}
-    @object.save
-  end
+  create.before :create_before
   
   # redirect to index (instead of r_c default of show view)
   create.response do |wants| 
@@ -33,11 +29,20 @@ class Admin::VariantsController < Admin::BaseController
     else
       flash[:notice] = "Variant could not be deleted"
     end
-    
-    redirect_to admin_product_variants_url(params[:product_id])
+
+    respond_to do |format|
+      format.html { redirect_to admin_product_variants_url(params[:product_id]) }
+      format.js  { render_js_for_destroy }
+    end
   end
   
   private 
+  def create_before 
+    option_values = params[:new_variant]
+    option_values.each_value {|id| @object.option_values << OptionValue.find(id)}
+    @object.save
+  end
+  
   def collection
     @deleted =  (params.key?(:deleted)  && params[:deleted] == "on") ? "checked" : ""
     

data/app/controllers/admin/zones_controller.rb

@@ -11,6 +11,8 @@ class Admin::ZonesController < Admin::BaseController
     wants.html { redirect_to collection_url }
   end
   
+  destroy.success.wants.js { render_js_for_destroy }
+  
   private
   def build_object
     @object ||= end_of_association_chain.send parent? ? :build : :new, object_params
@@ -19,7 +21,7 @@ class Admin::ZonesController < Admin::BaseController
   end
 
   def collection
-    @search = end_of_association_chain.search(params[:search])
+    @search = end_of_association_chain.searchlogic(params[:search])
     @search.order ||= "ascend_by_name"
     @collection_count = @search.count
     @collection = @search.paginate(:per_page => Spree::Config[:orders_per_page], :page => params[:page])

data/app/controllers/application_controller.rb

@@ -0,0 +1,4 @@
+class ApplicationController < Spree::BaseController
+  # This class is intentionally blank.  Keeping this class empty makes it easier to integrate Spree
+  # with an existing Rails application 
+end

data/app/controllers/checkouts_controller.rb

@@ -1,164 +1,228 @@
-class CheckoutsController < Spree::BaseController 
+class CheckoutsController < Spree::BaseController
+  include Spree::Checkout::Hooks
   include ActionView::Helpers::NumberHelper # Needed for JS usable rate information
+
   before_filter :load_data
-  before_filter :prevent_editing_complete_order, :only => [:edit, :update]
-  
+  before_filter :set_state
+  before_filter :enforce_registration, :except => :register
+  before_filter :ensure_payment_methods
+  helper :users
+
   resource_controller :singleton
-  belongs_to :order             
-  
-  layout 'application'   
-  ssl_required :update, :edit
+  actions :show, :edit, :update
+  belongs_to :order
+
+  ssl_required :update, :edit, :register
+
+  # GET /checkout is invalid but we'll assume a bookmark or user error and just redirect to edit (assuming checkout is still in progress)
+  show.wants.html { redirect_to edit_object_url }
+
+  edit.before :edit_hooks, :set_user
+  delivery.edit_hook :load_available_methods
+  address.edit_hook :set_ip_address
+  payment.edit_hook :load_available_payment_methods
+  update.before :clear_payments_if_in_payment_state
+
+  # customized verison of the standard r_c update method (since we need to handle gateway errors, etc)
+  def update      
+    load_object
+
+    # call the edit hooks for the current step in case we experience validation failure and need to edit again
+    edit_hooks
+    @checkout.enable_validation_group(@checkout.state.to_sym)
+
+    before :update
 
-  # alias original r_c method so we can handle any (gateway) exceptions that might be thrown
-  alias :rc_update :update
-  def update 
     begin
-      rc_update
-    rescue Spree::GatewayError => ge
-      flash[:error] = t("unable_to_authorize_credit_card") + ": #{ge.message}"
-      redirect_to edit_object_url and return
-    rescue Exception => oe
-      flash[:error] = t("unable_to_authorize_credit_card") + ": #{oe.message}"
-      logger.unknown "#{flash[:error]}  #{oe.backtrace.join("\n")}"
-      redirect_to edit_object_url and return
-    end
-  end
- 
-  update do
-    flash nil
-    
-    success.wants.html do  
-      if @order.checkout_complete 
-        if current_user
-          current_user.update_attribute(:bill_address, @order.bill_address)
-          current_user.update_attribute(:ship_address, @order.ship_address)
+      if object.update_attributes object_params
+        update_hooks
+        @order.update_totals!
+        after :update
+        next_step
+        if @checkout.completed_at
+          return complete_checkout
         end
-        flash[:notice] = t('order_processed_successfully')
-        order_params = {:checkout_complete => true}
-        order_params[:order_token] = @order.token unless @order.user
-        session[:order_id] = nil 
-        redirect_to order_url(@order, order_params) and next 
       else
-        # this means a failed filter which should have thrown an exception
-        flash[:notice] = "Unexpected error condition -- please contact site support"
-        redirect_to edit_object_url and next
-      end 
-    end 
-
-    success.wants.js do   
-      @order.reload
-      render :json => { :order_total => number_to_currency(@order.total),
-                        :charge_total => number_to_currency(@order.charge_total),
-                        :credit_total => number_to_currency(@order.credit_total),
-                        :charges => charge_hash,  
-                        :credits => credit_hash,
-                        :available_methods => rate_hash}.to_json,
-             :layout => false
+        after :update_fails
+        set_flash :update_fails
+      end
+    rescue Spree::GatewayError => ge
+      logger.debug("#{ge}:\n#{ge.backtrace.join("\n")}")
+      flash.now[:error] = t("unable_to_authorize_credit_card") + ": #{ge.message}"
     end
 
-    failure.wants.html do
-      flash[:notice] = "Unexpected failure in card authorization -- please contact site support"
-      redirect_to edit_object_url and next
-    end
-    failure.wants.js do   
-      render :json => "Unexpected failure in card authorization -- please contact site support"
-    end
+    render 'edit'
   end
-  
-  update.before do
-    # update user to current one if user has logged in
-    @order.update_attribute(:user, current_user) if current_user 
-
-    if (checkout_info = params[:checkout]) and not checkout_info[:coupon_code]
-      # overwrite any earlier guest checkout email if user has since logged in
-      checkout_info[:email] = current_user.email if current_user 
-
-      # and set the ip_address to the most recent one
-      checkout_info[:ip_address] = request.env['REMOTE_ADDR']
-
-      # check whether the bill address has changed, and start a fresh record if 
-      # we were using the address stored in the current user.
-      if checkout_info[:bill_address_attributes] and @checkout.bill_address
-        # always include the id of the record we must write to - ajax can't refresh the form
-        checkout_info[:bill_address_attributes][:id] = @checkout.bill_address.id
-        new_address = Address.new checkout_info[:bill_address_attributes]
-        if not @checkout.bill_address.same_as?(new_address) and
-             current_user and @checkout.bill_address == current_user.bill_address
-          # need to start a new record, so replace the existing one with a blank
-          checkout_info[:bill_address_attributes].delete :id  
-          @checkout.bill_address = Address.new
-        end
-      end
 
-      # check whether the ship address has changed, and start a fresh record if 
-      # we were using the address stored in the current user.
-      if checkout_info[:shipment_attributes][:address_attributes] and @order.shipment.address
-        # always include the id of the record we must write to - ajax can't refresh the form
-        checkout_info[:shipment_attributes][:address_attributes][:id] = @order.shipment.address.id
-        new_address = Address.new checkout_info[:shipment_attributes][:address_attributes]
-        if not @order.shipment.address.same_as?(new_address) and 
-             current_user and @order.shipment.address == current_user.ship_address 
-          # need to start a new record, so replace the existing one with a blank
-          checkout_info[:shipment_attributes][:address_attributes].delete :id
-          @order.shipment.address = Address.new
-        end
+  def register
+    load_object
+    @user = User.new
+    if request.method == :post
+      @checkout.email = params[:checkout][:email]
+      @checkout.enable_validation_group(:register)
+      if @checkout.email.present? and @checkout.save
+        redirect_to edit_object_url
       end
-
+      @checkout.errors.add t(:email) unless @checkout.email.present?
     end
-  end 
-  
-  update.after do
-    @order.save!		# expect messages here
-  end   
-    
+  end
+
+  def can_access?
+    session[:order_token] ||= params[:order_token]
+    parent_object.grant_access?(session[:order_token])
+  end
+
   private
+
+  def object_params
+    # For payment step, filter checkout parameters to produce the expected nested attributes for a single payment and its source, discarding attributes for payment methods other than the one selected
+    if object.payment?
+      if source_params = params.delete(:payment_source)[params[:checkout][:payments_attributes].first[:payment_method_id].underscore]
+        params[:checkout][:payments_attributes].first[:source_attributes] = source_params
+      end
+      params[:checkout][:payments_attributes].first[:amount] = @order.total
+    end
+    params[:checkout]
+  end
+
+  # Calls edit hooks registered for the current step
+  def edit_hooks
+    edit_hook @checkout.state.to_sym
+  end
+  # Calls update hooks registered for the current step
+  def update_hooks
+    update_hook @checkout.state.to_sym
+  end
+
+  def complete_checkout
+    complete_order
+    order_params = {:checkout_complete => true}
+    session[:order_id] = nil
+    flash[:commerce_tracking] = "Track Me in GA"
+    redirect_to order_url(@order, {:checkout_complete => true, :order_token => @order.token})
+  end
+
   def object
     return @object if @object
-    @object = parent_object.checkout                                                  
+    @object = parent_object.checkout
     unless params[:checkout] and params[:checkout][:coupon_code]
       # do not create these defaults if we're merely updating coupon code, otherwise we'll have a validation error
       if user = parent_object.user || current_user
-        @object.shipment.address ||= user.ship_address 
-        @object.bill_address     ||= user.bill_address
+        @object.ship_address ||= user.ship_address.clone unless user.ship_address.nil?
+        @object.bill_address ||= user.bill_address.clone unless user.bill_address.nil?
       end
-      @object.shipment.address ||= Address.default
-      @object.bill_address     ||= Address.default
-      @object.creditcard       ||= Creditcard.new(:month => Date.today.month, :year => Date.today.year)
+      @object.ship_address ||= Address.default
+      @object.bill_address ||= Address.default
     end
-    @object         
+    @object.email ||= params[:checkout][:email] if params[:checkout]
+    @object.email ||= current_user.email if current_user
+    @object
   end
-  
-  def load_data     
-    @countries = Country.find(:all).sort  
-    @shipping_countries = parent_object.shipping_countries.sort
-    if current_user && current_user.bill_address
-      default_country = current_user.bill_address.country 
+
+  def load_data
+    @countries = Checkout.countries.sort
+    if object.bill_address && object.bill_address.country
+      default_country = object.bill_address.country
+    elsif current_user && current_user.bill_address
+      default_country = current_user.bill_address.country
     else
-      default_country = Country.find Spree::Config[:default_country_id]	
-    end 
+      default_country = Country.find Spree::Config[:default_country_id]
+    end
     @states = default_country.states.sort
+
+    # prevent editing of a complete checkout
+    redirect_to order_url(parent_object) if parent_object.checkout_complete
+  end
+
+  def set_state
+    object.state = params[:step] || Checkout.state_machine.initial_state(nil).name
+    flash[:analytics] = "/checkout/#{object.state}"
+  end
+
+  def next_step
+    @checkout.next!
+    # call edit hooks for this next step since we're going to just render it (instead of issuing a redirect)
+    edit_hooks
+  end
+
+  def load_available_methods
+    @available_methods = rate_hash
+    @checkout.shipping_method_id ||= @available_methods.first[:id] unless @available_methods.empty?
+  end
+
+  def clear_payments_if_in_payment_state
+    if @checkout.payment?
+      @checkout.payments.clear
+    end
   end
   
-  def rate_hash       
-    fake_shipment = Shipment.new :order => @order, :address => @order.ship_address
-    @order.shipping_methods.collect do |ship_method|
-      fake_shipment.shipping_method = ship_method
-      { :id   => ship_method.id, 
-        :name => ship_method.name, 
-        :rate => number_to_currency(ship_method.calculate_cost(fake_shipment)) }
+  def load_available_payment_methods 
+    @payment_methods = PaymentMethod.available   
+    if @checkout.payment and @checkout.payment.payment_method
+      @payment_method = @checkout.payment.payment_method
+    else
+      @payment_method = @payment_methods.first
+    end
+  end
+
+  def set_ip_address
+    @checkout.update_attribute(:ip_address, request.env['REMOTE_ADDR'])
+  end
+
+  def complete_order
+    if @checkout.order.out_of_stock_items.empty?
+      flash[:notice] = t('order_processed_successfully')
+    else
+      flash[:notice] = t('order_processed_but_following_items_are_out_of_stock')
+      flash[:notice] += '<ul>'
+      @checkout.order.out_of_stock_items.each do |item|
+        flash[:notice] += '<li>' + t(:count_of_reduced_by,
+                              :name => item[:line_item].variant.name,
+                              :count => item[:count]) +
+                          '</li>'
+      end
+      flash[:notice] += '<ul>'
+    end
+  end
+
+  def rate_hash
+    begin
+      @checkout.shipping_methods.collect do |ship_method|
+        @checkout.shipment.shipping_method = ship_method
+        { :id => ship_method.id,
+          :name => ship_method.name,
+          :rate => number_to_currency(ship_method.calculate_cost(@checkout.shipment)) }
+      end
+    rescue Spree::ShippingError => ship_error
+      flash[:error] = ship_error.to_s
+      []
+    end
+  end
+
+  def enforce_registration
+    return if current_user or Spree::Config[:allow_anonymous_checkout]
+    return if Spree::Config[:allow_guest_checkout] and object.email.present?
+    store_location
+    redirect_to register_order_checkout_url(parent_object)
+  end
+
+  def set_user
+    if object.order.user.nil? && current_user
+      object.order.user = current_user
+      object.order.save
     end
   end
   
-  def charge_hash
-    Hash[*@order.charges.collect { |c| [c.description, number_to_currency(c.amount)] }.flatten]    
-  end           
+  def accurate_title
+    I18n.t(:checkout)
+  end
   
-  def credit_hash
-    Hash[*@order.credits.select {|c| c.amount !=0 }.collect { |c| [c.description, number_to_currency(c.amount)] }.flatten]    
+  def ensure_payment_methods
+    if PaymentMethod.available.none?
+      flash[:error] = t(:no_payment_methods_available)
+      redirect_to edit_order_path(params[:order_id])
+      false
+    end
   end
   
-  def prevent_editing_complete_order      
-    load_object
-    redirect_to order_url(parent_object) if @order.checkout_complete
-  end  
 end