My-Commerce_core 1.0.0

data/app/models/gateway/beanstream.rb

@@ -0,0 +1,187 @@
+class Gateway::Beanstream < Gateway
+  preference :login, :string
+  preference :user, :string
+  preference :password, :string
+  preference :secure_profile_api_key, :string
+
+  def provider_class
+    ActiveMerchant::Billing::BeanstreamGateway
+  end
+
+  def payment_profiles_supported?
+    true
+  end
+
+  def create_profile(payment)
+    creditcard = payment.source
+    if creditcard.gateway_customer_profile_id.nil?
+      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
+        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.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)
+    order = creditcard.payments.first.order
+    address = order.bill_address
+    { :email=>order.email,
+      :billing_address=>
+      { :name=>address.full_name,
+        :phone=>address.phone,
+        :address1=>address.address1,
+        :address2=>address.address2,
+        :city=>address.city,
+        :state=>address.state_name || address.state.abbr,
+        :country=>address.country.iso,
+        :zip=>address.zipcode
+      }
+    }.merge(gateway_options)
+  end
+
+  SECURE_PROFILE_URL = 'https://www.beanstream.com/scripts/payment_profile.asp'
+  SP_SERVICE_VERSION = '1.1'
+  PROFILE_OPERATIONS = {:new => 'N', :modify => 'M'}
+
+  ActiveMerchant::Billing::BeanstreamGateway.class_eval do
+
+    def store(credit_card, options = {})
+      post = {}
+      add_address(post, options)
+      add_credit_card(post, credit_card)
+      add_secure_profile_variables(post,options)
+      commit(post, true)
+    end
+
+    #can't actually delete a secure profile with the supplicaed API. This function sets the status of the profile to closed (C).
+    #Closed profiles will have to removed manually.
+    def delete(vault_id)
+      update(vault_id, false, {:status => "C"})
+    end
+
+    #alias_method :unstore, :delete
+
+    # Update the values (such as CC expiration) stored at
+    # the gateway.  The CC number must be supplied in the
+    # CreditCard object.
+    def update(vault_id, credit_card, options = {})
+      post = {}
+      add_address(post, options)
+      add_credit_card(post, credit_card)
+      options.merge!({:vault_id => vault_id, :operation => secure_profile_action(:modify)})
+      add_secure_profile_variables(post,options)
+      commit(post, true)
+    end
+
+    # CORE #
+
+    def secure_profile_action(type)
+      PROFILE_OPERATIONS[type] || PROFILE_OPERATIONS[:new]
+    end
+
+    def add_credit_card(post, credit_card)
+      if credit_card
+        if credit_card.has_payment_profile?
+          post[:customerCode] = credit_card.gateway_customer_profile_id
+        else
+          post[:trnCardOwner] = credit_card.name
+          post[:trnCardNumber] = credit_card.number
+          post[:trnExpMonth] = format(credit_card.month, :two_digits)
+          post[:trnExpYear] = format(credit_card.year, :two_digits)
+          post[:trnCardCvd] = credit_card.verification_value
+        end
+      end
+    end
+
+    def add_secure_profile_variables(post, options = {})
+      post[:serviceVersion] = SP_SERVICE_VERSION
+      post[:responseFormat] = 'QS'
+      post[:cardValidation] = (options[:cardValidation].to_i == 1) || '0'
+
+      post[:operationType] = options[:operationType] || options[:operation] || secure_profile_action(:new)
+      post[:customerCode] = options[:billing_id] || options[:vault_id] || false
+      post[:status] = options[:status]
+    end
+
+    def commit(params, use_profile_api = false)
+      post(post_data(params,use_profile_api),use_profile_api)
+    end
+
+    def post(data, use_profile_api)
+      response = parse(ssl_post((use_profile_api ? SECURE_PROFILE_URL : ActiveMerchant::Billing::BeanstreamGateway::URL), data))
+      response[:customer_vault_id] = response[:customerCode] if response[:customerCode]
+      build_response(success?(response), message_from(response), response,
+        :test => test? || response[:authCode] == "TEST",
+        :authorization => authorization_from(response),
+        :cvv_result => ActiveMerchant::Billing::BeanstreamGateway::CVD_CODES[response[:cvdId]],
+        :avs_result => { :code => (ActiveMerchant::Billing::BeanstreamGateway::AVS_CODES.include? response[:avsId]) ? ActiveMerchant::Billing::BeanstreamGateway::AVS_CODES[response[:avsId]] : response[:avsId] }
+      )
+    end
+
+    def message_from(response)
+      response[:messageText] || response[:responseMessage]
+    end
+
+    def success?(response)
+      response[:responseType] == 'R' || response[:trnApproved] == '1' || response[:responseCode] == '1'
+    end
+
+    def add_source(post, source)
+      if source.is_a?(String) or source.is_a?(Integer)
+        post[:customerCode] = source
+      else
+        source.type.to_s == "check" ? add_check(post, source) : add_credit_card(post, source)
+      end
+    end
+
+    def post_data(params, use_profile_api)
+      params[:requestType] = 'BACKEND'
+      if use_profile_api
+        params[:merchantId] = @options[:login]
+        params[:passCode] = @options[:secure_profile_api_key]
+      else
+        params[:username] = @options[:user] if @options[:user]
+        params[:password] = @options[:password] if @options[:password]
+        params[:merchant_id] = @options[:login]
+      end
+      params[:vbvEnabled] = '0'
+      params[:scEnabled] = '0'
+
+      params.reject{|k, v| v.blank?}.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+    end
+
+  end
+
+end

data/app/models/gateway/bogus.rb

@@ -0,0 +1,80 @@
+class Gateway::Bogus < Gateway
+  TEST_VISA = "4111111111111111"
+  TEST_MC = "5500000000000004"
+  TEST_AMEX = "340000000000009"
+  TEST_DISC = "6011000000000004"
+
+  VALID_CCS = ["1", TEST_VISA, TEST_MC, TEST_AMEX, TEST_DISC]
+
+  attr_accessor :test
+
+  def provider_class
+    self.class
+  end
+
+  def preferences
+    {}
+  end
+
+  def create_profile(payment)
+    # simulate the storage of credit card profile using remote service
+    success = VALID_CCS.include? payment.source.number
+    payment.source.update_attributes(:gateway_customer_profile_id => generate_profile_id(success))
+  end
+
+  def authorize(money, creditcard, options = {})
+    profile_id = creditcard.gateway_customer_profile_id
+    if VALID_CCS.include? creditcard.number or (profile_id and profile_id.starts_with? "BGS-")
+      ActiveMerchant::Billing::Response.new(true, "Bogus Gateway: Forced success", {}, :test => true, :authorization => '12345', :avs_result => {:code => 'A'})
+    else
+      ActiveMerchant::Billing::Response.new(false, "Bogus Gateway: Forced failure", {:message => 'Bogus Gateway: Forced failure'}, :test => true)
+    end
+  end
+
+  def purchase(money, creditcard, options = {})
+    profile_id = creditcard.gateway_customer_profile_id
+    if VALID_CCS.include? creditcard.number  or (profile_id and profile_id.starts_with? "BGS-")
+      ActiveMerchant::Billing::Response.new(true, "Bogus Gateway: Forced success", {}, :test => true, :authorization => '12345', :avs_result => {:code => 'A'})
+    else
+      ActiveMerchant::Billing::Response.new(false, "Bogus Gateway: Forced failure", :message => 'Bogus Gateway: Forced failure', :test => true)
+    end
+  end
+
+  def credit(money, creditcard, response_code, options = {})
+    ActiveMerchant::Billing::Response.new(true, "Bogus Gateway: Forced success", {}, :test => true, :authorization => '12345')
+  end
+
+  def capture(authorization, creditcard, gateway_options)
+    if authorization.response_code == "12345"
+      ActiveMerchant::Billing::Response.new(true, "Bogus Gateway: Forced success", {}, :test => true, :authorization => '67890')
+    else
+      ActiveMerchant::Billing::Response.new(false, "Bogus Gateway: Forced failure", :error => 'Bogus Gateway: Forced failure', :test => true)
+    end
+
+  end
+
+  def void(response_code, creditcard, options = {})
+    ActiveMerchant::Billing::Response.new(true, "Bogus Gateway: Forced success", {}, :test => true, :authorization => '12345')
+  end
+
+  def test?
+    # Test mode is not really relevant with bogus gateway (no such thing as live server)
+    true
+  end
+
+  def payment_profiles_supported?
+    true
+  end
+
+  private
+  def generate_profile_id(success)
+    record = true
+    prefix = success ? "BGS" : "FAIL"
+    while record
+      random = "#{prefix}-#{Array.new(6){rand(6)}.join}"
+      record = Creditcard.find(:first, :conditions => ["gateway_customer_profile_id = ?", random])
+    end
+    random
+  end
+
+end

data/app/models/gateway/braintree.rb

@@ -0,0 +1,88 @@
+class Gateway::Braintree < Gateway
+	preference :merchant_id, :string
+	preference :public_key, :string
+	preference :private_key, :string
+
+  def provider_class
+    ActiveMerchant::Billing::BraintreeGateway
+  end
+
+  def authorize(money, creditcard, options = {})
+    adjust_options_for_braintree(creditcard, options)
+    payment_method = creditcard.gateway_customer_profile_id || creditcard
+    provider.authorize(money, payment_method, options)
+  end
+
+  def capture(authorization, ignored_creditcard, ignored_options)
+    amount = (authorization.amount * 100).to_i
+    provider.capture(amount, authorization.response_code)
+  end
+
+  def create_profile(payment)
+    if payment.source.gateway_customer_profile_id.nil?
+      response = provider.store(payment.source)
+      if response.success?
+        payment.source.update_attributes!(:gateway_customer_profile_id => response.params["customer_vault_id"])
+      else
+        payment.source.gateway_error response.message
+      end
+    end
+  end
+
+  def credit(*args)
+    if args.size == 4
+      credit_with_payment_profiles(*args)
+    elsif args.size == 3
+      credit_without_payment_profiles(*args)
+    else
+      raise ArgumentError, "Expected 3 or 4 arguments, received #{args.size}"
+    end
+  end
+
+  def credit_with_payment_profiles(amount, payment, response_code, option)
+    provider.credit(amount, payment)
+  end
+
+  def credit_without_payment_profiles(amount, response_code, options)
+    transaction = ::Braintree::Transaction.find(response_code)
+    if BigDecimal.new(amount.to_s) == (transaction.amount * 100)
+      provider.refund(response_code)
+    else
+      raise NotImplementedError
+    end
+  end
+
+  def payment_profiles_supported?
+    true
+  end
+
+  def purchase(money, creditcard, options = {})
+    authorize(money, creditcard, options.merge(:submit_for_settlement => true))
+  end
+
+  def void(response_code, ignored_options)
+    provider.void(response_code)
+  end
+
+  protected
+
+  def adjust_country_name(options)
+    [:billing_address, :shipping_address].each do |address|
+      if options[address] && options[address][:country] == "US"
+        options[address][:country] = "United States of America"
+      end
+    end
+  end
+
+  def adjust_billing_address(creditcard, options)
+    if creditcard.gateway_customer_profile_id
+      options.delete(:billing_address)
+    end
+  end
+
+  def adjust_options_for_braintree(creditcard, options)
+    adjust_country_name(options)
+    adjust_billing_address(creditcard, options)
+  end
+end
+

data/app/models/gateway/eway.rb

@@ -0,0 +1,11 @@
+class Gateway::Eway < Gateway
+  preference :login, :string
+
+  # Note: EWay supports purchase method only (no authorize method).
+  # Ensure Spree::Config[:auto_capture] is set to true
+
+  def provider_class
+    ActiveMerchant::Billing::EwayGateway
+  end
+
+end

data/app/models/gateway/linkpoint.rb

@@ -0,0 +1,8 @@
+class Gateway::Linkpoint < Gateway
+	preference :login, :string
+	preference :pem, :text
+
+  def provider_class
+    ActiveMerchant::Billing::LinkpointGateway
+  end
+end

data/app/models/gateway/pay_pal.rb

@@ -0,0 +1,11 @@
+class Gateway::PayPal < Gateway
+	preference :login, :string
+	preference :password, :string
+	preference :signature, :string
+	preference :currency_code, :string
+
+  def provider_class
+		ActiveMerchant::Billing::PaypalGateway
+  end	
+
+end

data/app/models/gateway/sage_pay.rb

@@ -0,0 +1,9 @@
+class Gateway::SagePay < Gateway
+  preference :login, :string
+  preference :password, :string
+  preference :account, :string
+
+  def provider_class
+    ActiveMerchant::Billing::SagePayGateway
+  end	
+end

data/app/models/gateway.rb

@@ -0,0 +1,48 @@
+class Gateway < PaymentMethod
+	delegate_belongs_to :provider, :authorize, :purchase, :capture, :void, :credit
+
+	validates :name, :type, :presence => true
+
+  preference :server, :string, :default => 'test'
+  preference :test_mode, :boolean, :default => true
+
+  def payment_source_class
+    Creditcard
+  end
+
+  # instantiates the selected gateway and configures with the options stored in the database
+  def self.current
+    super
+	end
+
+  def provider
+    gateway_options = options
+    ActiveMerchant::Billing::Base.gateway_mode = gateway_options[:server].to_sym
+    @provider ||= provider_class.new(gateway_options)
+  end
+
+	def options
+    options_hash = {}
+    self.preferences.each do |key,value|
+      options_hash[key.to_sym] = value
+    end
+    options_hash
+	end
+
+	def method_missing(method, *args)
+	 	if @provider.nil? || !@provider.respond_to?(method)
+			super
+		else
+      provider.send(method)
+		end
+	end
+
+	def payment_profiles_supported?
+	  false
+  end
+
+  def method_type
+    "gateway"
+  end
+
+end

data/app/models/image.rb

@@ -0,0 +1,31 @@
+class Image < Asset
+  validate :no_attachement_errors
+  has_attached_file :attachment,
+                    :styles => { :mini => '48x48>', :small => '100x100>', :product => '240x240>', :large => '600x600>' },
+                    :default_style => :product,
+                    :url => "/assets/products/:id/:style/:basename.:extension",
+                    :path => ":rails_root/public/assets/products/:id/:style/:basename.:extension"
+
+  # save the w,h of the original image (from which others can be calculated)
+  # we need to look at the write-queue for images which have not been saved yet
+  after_post_process :find_dimensions
+
+  def find_dimensions
+    temporary = attachment.queued_for_write[:original]
+    filename = temporary.path unless temporary.nil?
+    filename = attachment.path if filename.blank?
+    geometry = Paperclip::Geometry.from_file(filename)
+    self.attachment_width  = geometry.width
+    self.attachment_height = geometry.height
+  end
+
+  # if there are errors from the plugin, then add a more meaningful message
+  def no_attachement_errors
+    unless attachment.errors.empty?
+      # uncomment this to get rid of the less-than-useful interrim messages
+      # errors.clear
+      errors.add :attachment, "Paperclip returned errors for file '#{attachment_file_name}' - check ImageMagick installation or image source file."
+      false
+    end
+  end
+end

data/app/models/inventory_unit.rb

@@ -0,0 +1,119 @@
+class InventoryUnit < ActiveRecord::Base
+  belongs_to :variant
+  belongs_to :order
+  belongs_to :shipment
+  belongs_to :return_authorization
+
+  scope :backorder, where(:state => 'backordered')
+
+  # state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
+  state_machine :initial => 'on_hand' do
+    event :fill_backorder do
+      transition :to => 'sold', :from => 'backordered'
+    end
+    event :ship do
+      transition :to => 'shipped', :if => :allow_ship?
+    end
+    event :return do
+      transition :to => 'returned', :from => 'shipped'
+    end
+
+    after_transition :on => :fill_backorder, :do => :update_order
+    after_transition :to => 'returned', :do => :restock_variant
+  end
+
+  # method deprecated in favour of adjust_units (which creates & destroys units as needed).
+  def self.sell_units(order)
+    warn "[DEPRECATION] `InventoryUnits#sell_units` is deprecated.  Please use `InventoryUnits#assign_opening_inventory` instead. (called from #{caller[0]})"
+    self.adjust_units(order)
+  end
+
+  # Assigns inventory to a newly completed order.
+  # Should only be called once during the life-cycle of an order, on transition to completed.
+  #
+  def self.assign_opening_inventory(order)
+    return [] unless order.completed?
+
+    #increase inventory to meet initial requirements
+    order.line_items.each do |line_item|
+      increase(order, line_item.variant, line_item.quantity)
+    end
+  end
+
+  # manages both variant.count_on_hand and inventory unit creation
+  #
+  def self.increase(order, variant, quantity)
+    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
+    if Spree::Config[:create_inventory_units]
+      create_units(order, variant, sold, back_order)
+    end
+  end
+
+  def self.decrease(order, variant, quantity)
+    if Spree::Config[:track_inventory_levels]
+       variant.increment!(:count_on_hand, quantity)
+    end
+
+    if Spree::Config[:create_inventory_units]
+      destroy_units(order, variant, quantity)
+    end
+  end
+
+  # find the specified quantity of units with the specified status
+  def self.find_by_status(variant, quantity, status)
+    variant.inventory_units.where(:status => status).limit(quantity)
+  end
+
+  private
+  def allow_ship?
+    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)
+
+    quantity.times do
+      inventory_unit = variant_units.shift
+      inventory_unit.destroy
+    end
+  end
+
+  def self.create_units(order, variant, sold, back_order)
+    if back_order > 0 && !Spree::Config[:allow_backorders]
+      raise "Cannot request back orders when backordering is disabled"
+    end
+
+    shipment = order.shipments.detect {|shipment| !shipment.shipped? }
+
+    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
+    self.order.update!
+  end
+
+  def restock_variant
+    self.variant.on_hand = (self.variant.on_hand + 1)
+    self.variant.save
+  end
+
+end

data/app/models/line_item.rb

@@ -0,0 +1,95 @@
+class LineItem < ActiveRecord::Base
+  before_validation :adjust_quantity
+  belongs_to :order
+  belongs_to :variant
+
+  has_one :product, :through => :variant
+
+  before_validation :copy_price
+
+  validates :variant, :presence => true
+  validates :quantity, :numericality => { :only_integer => true, :message => I18n.t("validation.must_be_int") }
+  validates :price, :numericality => true
+  # validate :meta_validation_of_quantities
+
+  attr_accessible :quantity
+
+  before_save :update_inventory
+  before_destroy :ensure_not_shipped, :remove_inventory
+
+  after_save :update_order
+  after_destroy :update_order
+
+  def copy_price
+    self.price = variant.price if variant && self.price.nil?
+  end
+
+  # def meta_validation_of_quantities
+  #   unless quantity && quantity >= 0
+  #     errors.add(:quantity, I18n.t("validation.must_be_non_negative"))
+  #   end
+  #   # avoid reload of order.inventory_units by using direct lookup
+  #   unless !Spree::Config[:track_inventory_levels]                        ||
+  #          Spree::Config[:allow_backorders]                               ||
+  #          order   && InventoryUnit.order_id_equals(order).first.present? ||
+  #          variant && quantity <= variant.on_hand
+  #     errors.add(:quantity, I18n.t("validation.is_too_large") + " (#{self.variant.name})")
+  #   end
+  #
+  #   if shipped_count = order.shipped_units.nil? ? nil : order.shipped_units[variant]
+  #     errors.add(:quantity, I18n.t("validation.cannot_be_less_than_shipped_units") ) if quantity < shipped_count
+  #   end
+  # end
+
+  def increment_quantity
+    self.quantity += 1
+  end
+
+  def decrement_quantity
+    self.quantity -= 1
+  end
+
+  def amount
+    self.price * self.quantity
+  end
+  alias total amount
+
+  def adjust_quantity
+    self.quantity = 0 if self.quantity.nil? || self.quantity < 0
+  end
+
+  private
+    def update_inventory
+      return true unless self.order.completed?
+
+      if self.new_record?
+        InventoryUnit.increase(self.order, self.variant, self.quantity)
+      elsif old_quantity = self.changed_attributes["quantity"]
+        if old_quantity < self.quantity
+          InventoryUnit.increase(self.order, self.variant, (self.quantity - old_quantity))
+        elsif old_quantity > self.quantity
+          InventoryUnit.decrease(self.order, self.variant, (old_quantity - self.quantity))
+        end
+      end
+
+    end
+
+    def remove_inventory
+      return true unless self.order.completed?
+
+      InventoryUnit.decrease(self.order, self.variant, self.quantity)
+    end
+
+    def update_order
+      # update the order totals, etc.
+      order.update!
+    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
+