spree_core 0.30.2 → 0.40.0

data/app/models/calculator/vat.rb

@@ -12,7 +12,7 @@ class Calculator::Vat < Calculator
   # list the vat rates for the default country
   def self.default_rates
     origin = Country.find(Spree::Config[:default_country_id])
-    calcs = Calculator::Vat.find(:all, :include => {:calculable => :zone}).select {
+    calcs = Calculator::Vat.includes(:calculable => :zone).select {
       |vat| vat.calculable.zone.country_list.include?(origin)
     }
     calcs.collect { |calc| calc.calculable }

data/app/models/creditcard.rb

@@ -134,7 +134,7 @@ class Creditcard < ActiveRecord::Base
   end
 
   def credit(payment)
-    amount = payment.credit_allowed >= payment.order.outstanding_balance.abs ? payment.order.outstanding_balance : payment.credit_allowed
+    amount = payment.credit_allowed >= payment.order.outstanding_balance.abs ? payment.order.outstanding_balance.abs : payment.credit_allowed.abs
 
     if payment_gateway.payment_profiles_supported?
       response = payment_gateway.credit((amount * 100).round, self, payment.response_code, minimal_gateway_options(payment))

data/app/models/gateway/authorize_net.rb

@@ -1,8 +1,19 @@
 class Gateway::AuthorizeNet < Gateway
 	preference :login, :string
 	preference :password, :string
-	
+
   def provider_class
     ActiveMerchant::Billing::AuthorizeNetGateway
-  end	
+  end
+
+  def options
+    # add :test key in the options hash, as that is what the ActiveMerchant::Billing::AuthorizeNetGateway expects
+    if self.prefers? :test_mode
+      self.class.default_preferences[:test] = true
+    else
+      self.class.default_preferences.delete(:test)
+    end
+
+    super
+  end
 end

data/app/models/gateway/authorize_net_cim.rb

@@ -12,6 +12,17 @@ class Gateway::AuthorizeNetCim < Gateway
     self.class
   end
 
+  def options
+    # add :test key in the options hash, as that is what the ActiveMerchant::Billing::AuthorizeNetGateway expects
+    if self.prefers? :test_mode
+      self.class.default_preferences[:test] = true
+    else
+      self.class.default_preferences.delete(:test)
+    end
+
+    super
+  end
+
   def authorize(amount, creditcard, gateway_options)
     create_transaction(amount, creditcard, :auth_only)
   end

data/app/models/gateway/beanstream.rb

@@ -12,29 +12,52 @@ class Gateway::Beanstream < Gateway
     true
   end
 
-  def create_profile(creditcard, gateway_options)
+  def create_profile(payment)
+    creditcard = payment.source
     if creditcard.gateway_customer_profile_id.nil?
-      options = options_for_create_customer_profile(creditcard, gateway_options)
+      options = options_for_create_customer_profile(creditcard, {})
       verify_creditcard_name!(creditcard)
       result = provider.store(creditcard, options)
       if result.success?
         creditcard.update_attributes(:gateway_customer_profile_id => result.params["customerCode"], :gateway_payment_profile_id => result.params["customer_vault_id"])
       else
-        raise "Error creating profile: #{result.message}"
+        creditcard.gateway_error(result) if creditcard.respond_to? :gateway_error
+        creditcard.source.gateway_error(result)
       end
     end
   end
+  
+  def capture(transaction, creditcard, gateway_options)
+    beanstream_gateway.capture((transaction.amount*100).round, transaction.response_code, gateway_options)
+  end
+  
+  def void(transaction_response, creditcard, gateway_options)
+    beanstream_gateway.void(transaction_response, gateway_options)
+  end
+
+  def credit(amount, creditcard, response_code, gateway_options = {})
+    amount = (amount * -1) if amount < 0
+    beanstream_gateway.credit(amount, response_code, gateway_options)
+  end
+
   private
+  
+  def beanstream_gateway
+    ActiveMerchant::Billing::Base.gateway_mode = preferred_server.to_sym
+    gateway_options = options
+    ActiveMerchant::Billing::BeanstreamGateway.new(gateway_options)
+  end
+  
   def verify_creditcard_name!(creditcard)
-    bill_address = creditcard.payments.first.payable.bill_address
+    bill_address = creditcard.payments.first.order.bill_address
     creditcard.first_name = bill_address.firstname unless creditcard.first_name?
     creditcard.last_name = bill_address.lastname   unless creditcard.last_name?
   end
 
   def options_for_create_customer_profile(creditcard, gateway_options)
-    checkout = creditcard.payments.first.payable
-    address = checkout.bill_address
-    { :email=>checkout.email,
+    order = creditcard.payments.first.order
+    address = order.bill_address
+    { :email=>order.email,
       :billing_address=>
       { :name=>address.full_name,
         :phone=>address.phone,

data/app/models/inventory_unit.rb

@@ -34,42 +34,27 @@ class InventoryUnit < ActiveRecord::Base
   def self.assign_opening_inventory(order)
     return [] unless order.completed?
 
-    out_of_stock_items = []
-
     #increase inventory to meet initial requirements
     order.line_items.each do |line_item|
-      out_of_stock_items.concat increase(order, line_item.variant, line_item.quantity)
+      increase(order, line_item.variant, line_item.quantity)
     end
-
-    out_of_stock_items
   end
 
   # manages both variant.count_on_hand and inventory unit creation
   #
   def self.increase(order, variant, quantity)
-    # calculate number of sold vs. backordered units
-    if variant.count_on_hand == 0
-      back_order = quantity
-      sold = 0
-    elsif variant.count_on_hand < quantity
-      back_order = quantity - (variant.count_on_hand < 0 ? 0 : variant.count_on_hand)
-      sold = quantity - back_order
-    else
-      back_order = 0
-      sold = quantity
-    end
+    back_order = determine_backorder(order, variant, quantity)
+    sold = quantity - back_order
 
     #set on_hand if configured
     if Spree::Config[:track_inventory_levels]
       variant.decrement!(:count_on_hand, quantity)
     end
 
-    #create units if configured, returning any backorderd variants with count
-    out_of_stock_items = []
+    #create units if configured
     if Spree::Config[:create_inventory_units]
-      out_of_stock_items = create_units(order, variant, sold, back_order)
+      create_units(order, variant, sold, back_order)
     end
-    out_of_stock_items
   end
 
   def self.decrease(order, variant, quantity)
@@ -84,9 +69,7 @@ class InventoryUnit < ActiveRecord::Base
 
   # find the specified quantity of units with the specified status
   def self.find_by_status(variant, quantity, status)
-    variant.inventory_units.find(:all,
-                                 :conditions => ['status = ? ', status],
-                                 :limit => quantity)
+    variant.inventory_units.where(:status => status).limit(quantity)
   end
 
   private
@@ -94,6 +77,16 @@ class InventoryUnit < ActiveRecord::Base
     Spree::Config[:allow_backorder_shipping] || self.sold?
   end
 
+  def self.determine_backorder(order, variant, quantity)
+    if variant.on_hand == 0
+      quantity
+    elsif variant.on_hand.present? and variant.on_hand < quantity
+      quantity - (variant.on_hand < 0 ? 0 : variant.on_hand)
+    else
+      0
+    end
+  end
+
   def self.destroy_units(order, variant, quantity)
     variant_units = order.inventory_units.group_by(&:variant_id)[variant.id].sort_by(&:state)
 
@@ -104,17 +97,14 @@ class InventoryUnit < ActiveRecord::Base
   end
 
   def self.create_units(order, variant, sold, back_order)
-    shipment = order.shipments.detect {|shipment| !shipment.shipped? }
-
-    sold.times do
-      order.inventory_units.create(:variant => variant, :state => "sold", :shipment => shipment)
+    if back_order > 0 && !Spree::Config[:allow_backorders]
+      raise "Cannot request back orders when backordering is disabled"
     end
 
-    if Spree::Config[:allow_backorders]
-      back_order.times { order.inventory_units.create(:variant => variant, :state => "backordered", :shipment => shipment) }
-    end
+    shipment = order.shipments.detect {|shipment| !shipment.shipped? }
 
-    back_order == 0 ? [] : [{:variant => variant, :count => back_order}]
+    sold.times { order.inventory_units.create(:variant => variant, :state => "sold", :shipment => shipment) }
+    back_order.times { order.inventory_units.create(:variant => variant, :state => "backordered", :shipment => shipment) }
   end
 
   def update_order

data/app/models/line_item.rb

@@ -6,7 +6,6 @@ class LineItem < ActiveRecord::Base
   has_one :product, :through => :variant
 
   before_validation :copy_price
-  #before_destroy :ensure_not_shipped
 
   validates :variant, :presence => true
   validates :quantity, :numericality => { :only_integer => true, :message => I18n.t("validation.must_be_int") }
@@ -16,7 +15,7 @@ class LineItem < ActiveRecord::Base
   attr_accessible :quantity
 
   before_save :update_inventory
-  before_destroy :remove_inventory
+  before_destroy :ensure_not_shipped, :remove_inventory
 
   after_save :update_order
   after_destroy :update_order
@@ -86,11 +85,11 @@ class LineItem < ActiveRecord::Base
       order.update!
     end
 
-  # def ensure_not_shipped
-  #   if shipped_count = order.shipped_units.nil? ? nil : order.shipped_units[variant]
-  #     errors.add_to_base I18n.t("cannot_destory_line_item_as_inventory_units_have_shipped")
-  #     return false
-  #   end
-  # end
+    def ensure_not_shipped
+      if order.try(:inventory_units).to_a.any?{|unit| unit.variant_id == variant_id && unit.shipped?}
+        errors.add :base, I18n.t("cannot_destory_line_item_as_inventory_units_have_shipped")
+        return false
+     end
+  end
 end
 

data/app/models/order.rb

@@ -347,10 +347,13 @@ class Order < ActiveRecord::Base
     bill_address.try(:lastname)
   end
 
+  def products
+    line_items.map{|li| li.variant.product}
+  end
 
   private
   def create_user
-    self.email = user.email if self.user and user.email !~ /example.net/
+    self.email = user.email if self.user and not user.anonymous?
     self.user ||= User.anonymous!
   end
 

data/app/models/product_group.rb

@@ -90,14 +90,10 @@ class ProductGroup < ActiveRecord::Base
   end
 
   def add_scope(scope_name, arguments=[])
-    if scope_name.to_s !~ /eval|send|system|[^a-z0-9_!?]/
-      self.product_scopes << ProductScope.new({
-          :name => scope_name.to_s,
-          :arguments => [*arguments]
-        })
-    else
-      raise ArgumentError.new("'#{scope_name}` can't be used as scope")
-    end
+    self.product_scopes << ProductScope.new({
+        :name => scope_name.to_s,
+        :arguments => [*arguments]
+      })
     self
   end
 

data/app/models/property.rb

@@ -13,8 +13,6 @@ class Property < ActiveRecord::Base
     if prototype.class == Prototype
       id = prototype.id
     end
-
-    find(:all, :conditions => [ 'prototype_id = ?', id ],
-         :joins => 'left join properties_prototypes on property_id = properties.id')
+    joins('left join properties_prototypes on property_id = properties.id').where('prototype_id = ?', id)
   end
 end

data/app/models/return_authorization.rb

@@ -2,6 +2,7 @@ class ReturnAuthorization < ActiveRecord::Base
   belongs_to :order
   has_many :inventory_units
   before_create :generate_number
+  before_save :force_positive_amount
 
   validates :order, :presence => true
   validates :amount, :numericality => true
@@ -64,11 +65,15 @@ class ReturnAuthorization < ActiveRecord::Base
   def process_return
     inventory_units.each &:return!
 
-    credit = Adjustment.create(:source => self, :order_id => self.order.id, :amount => (self.amount > 0 ? self.amount * -1 : self.amount), :label => I18n.t("rma_credit"))
+    credit = Adjustment.create(:source => self, :order_id => self.order.id, :amount => self.amount.abs * -1, :label => I18n.t("rma_credit"))
     self.order.update!
   end
 
   def allow_receive?
     !inventory_units.empty?
   end
+
+  def force_positive_amount
+    self.amount = self.amount.abs
+  end
 end

data/app/models/state_event.rb

@@ -8,9 +8,9 @@ class StateEvent < ActiveRecord::Base
   end
 
   def assign_user
-    if UserSession.activated? && current_user_session = UserSession.find
-      self.user_id ||= current_user_session.user.id
-    end
+    # if Session.activated? && current_user_session = Session.find
+    #   self.user_id ||= current_user_session.user.id
+    # end
     true   # don't stop the filters
   end
 end

data/app/models/state_monitor.rb

@@ -4,22 +4,22 @@ class StateMonitor < ActiveRecord::Observer
   # Generic transition callback *after* the transition is performed
   def after_transition(object, transition)
 
-    current_user_session = UserSession.activated? ? UserSession.find : nil
-
-    if current_user_session
-      author = current_user_session.user
-    elsif object.respond_to?(:user)
-      author = object.user
-    end
-
-    to_state = transition.attributes[:to_name]
-    object.state_events.create({
-      :previous_state => transition.attributes[:from],
-      :name           => transition.attributes[:event].to_s,
-      :user_id        => author && author.id 
-      })
-
-    ActiveRecord::Base.logger.info("#{object.class}##{object.id}: #{transition.attributes[:from]} => #{transition.attributes[:to]}")
+    # current_user_session = Session.activated? ? Session.find : nil
+    #
+    # if current_user_session
+    #   author = current_user_session.user
+    # elsif object.respond_to?(:user)
+    #   author = object.user
+    # end
+    #
+    # to_state = transition.attributes[:to_name]
+    # object.state_events.create({
+    #   :previous_state => transition.attributes[:from],
+    #   :name           => transition.attributes[:event].to_s,
+    #   :user_id        => author && author.id
+    #   })
+    #
+    # ActiveRecord::Base.logger.info("#{object.class}##{object.id}: #{transition.attributes[:from]} => #{transition.attributes[:to]}")
   end
 
 end

data/app/models/taxon.rb

@@ -18,14 +18,13 @@ class Taxon < ActiveRecord::Base
   # this method should be customized to your own site
   include ::ProductFilters  # for detailed defs of filters
   def applicable_filters
-    fs  = []
-    fs << ProductFilters.taxons_below(self)
+    fs = []
+    # fs << ProductFilters.taxons_below(self)
     ## unless it's a root taxon? left open for demo purposes
-    fs += [
-      ProductFilters.price_filter,
-      ProductFilters.brand_filter,
-      #ProductFilters.selective_brand_filter(self) 
-      ]
+    
+    fs << ProductFilters.price_filter if ProductFilters.respond_to?(:price_filter)
+    fs << ProductFilters.brand_filter if ProductFilters.respond_to?(:brand_filter)
+    fs
   end
 
   # Creates permalink based on .to_url method provided by stringx gem

data/app/models/user.rb

@@ -5,6 +5,10 @@ class User < ActiveRecord::Base
   belongs_to :ship_address, :foreign_key => "ship_address_id", :class_name => "Address"
   belongs_to :bill_address, :foreign_key => "bill_address_id", :class_name => "Address"
 
+  def anonymous?
+    false
+  end
+
   # Creates an anonymous user
   def self.anonymous!
     User.create

data/app/views/admin/general_settings/edit.html.erb

@@ -28,14 +28,6 @@
     </label>
   </p>
 
-  <p>
-    <label>
-      <input name="preferences[check_for_spree_alerts]" type="hidden" value="0" />
-      <%= check_box_tag('preferences[check_for_spree_alerts]', "1", Spree::Config[:check_for_spree_alerts]) %>
-      <%= t('spree_alert_checking') %>
-    </label>
- </p>
-
   <p class="form-buttons">
     <%= button t('update') %> 
     <%= t("or") %> <%= link_to t("cancel"), admin_general_settings_url %>

data/app/views/admin/general_settings/show.html.erb

@@ -4,30 +4,25 @@
 
 <table>
   <tr>
-    <th scope="row"><%= t("site_name") %>:</th>
+    <th scope="row"><%= t("site_name") %>:</th> 
     <td><%=  Spree::Config[:site_name] %></td>
   </tr>
   <tr>
-    <th scope="row"><%= t("site_url") %>:</th>
+    <th scope="row"><%= t("site_url") %>:</th> 
     <td><%=  Spree::Config[:site_url] %></td>
   </tr>
   <tr>
 	<td colspan="2">
-	  <%= (Spree::Config[:allow_ssl_in_production] ? t("ssl_will_be_used_in_production_mode") : t("ssl_will_not_be_used_in_production_mode")) %>
+	  <%= (Spree::Config[:allow_ssl_in_production] ? t("ssl_will_be_used_in_production_mode") : t("ssl_will_not_be_used_in_production_mode")) %> 
 	</td>
   </tr>
   <tr>
 	<td colspan="2">
 	  <%= (Spree::Config[:allow_ssl_in_development_and_test] ? t("ssl_will_be_used_in_development_and_test_modes") : t("ssl_will_not_be_used_in_development_and_test_modes")) %>
-	</td>
-  </tr>
-  <tr>
-    <td colspan="2">
-      <%= (Spree::Config[:check_for_spree_alerts] ? t("spree_alert_checking") : t("spree_alert_not_checking")) %>
-    </td>
+	</td>	
   </tr>
 </table>
 
-<p><%= link_to_with_icon 'edit', t("edit"), edit_admin_general_settings_path, :id => 'admin_general_settings_link' %></p>
+<p><%= link_to_with_icon 'edit', t("edit"), edit_admin_general_settings_path %></p>