camaleon_ecommerce 1.1 → 1.2

data/app/helpers/plugins/ecommerce/ecommerce_payment_helper.rb

@@ -1,61 +1,6 @@
 module Plugins::Ecommerce::EcommercePaymentHelper
-  include Plugins::Ecommerce::EcommerceHelper
-
-  def payment_pay_by_credit_card_authorize_net(order, payment_method)
-    billing_address = order.get_meta("billing_address")
-    details = order.get_meta("details")
-    amount = commerce_to_cents(order.total_amount)
-    payment_params = {
-      :order_id => order.slug,
-      :currency => current_site.currency_code,
-      :email => order.user.email,
-      :billing_address => {:name => "#{order.user.fullname}",
-                           :address1 => billing_address[:address1],
-                           :address2 => billing_address[:address2],
-                           :city => billing_address[:city],
-                           :state => billing_address[:state],
-                           :country => billing_address[:country],
-                           :zip => billing_address[:zip]
-      },
-      :description => 'Buy Products',
-      :ip => request.remote_ip
-    }
-
-    authorize_net_options = {
-      :login => payment_method.options[:authorize_net_login_id],
-      :password => payment_method.options[:authorize_net_transaction_key]
-    }
-
-    ActiveMerchant::Billing::Base.mode = payment_method.options[:authorize_net_sandbox].to_s.to_bool ? :test : :production
-
-    credit_card = ActiveMerchant::Billing::CreditCard.new(
-      :first_name => params[:firstName],
-      :last_name => params[:lastName],
-      :number => params[:cardNumber],
-      :month => params[:expMonth],
-      :year => "20#{params[:expYear]}",
-      :verification_value => params[:cvCode]
-    )
-    if credit_card.validate.empty?
-      gateway = ActiveMerchant::Billing::AuthorizeNetGateway.new(authorize_net_options)
-      response = gateway.purchase(amount, credit_card, payment_params)
-      if response.success?
-        order.set_meta('pay_authorize_net', payment_params)
-        return {}
-      else
-        return {error: response.message}
-      end
-    else
-      return {error: credit_card.validate.map{|k, v| "#{k}: #{v.join(', ')}"}.join('<br>')}
-    end
-  end
-
   def commerce_to_cents(money)
-    (money*100).round
-  end
-
-  def commerce_current_currency
-    current_site.get_meta("_setting_ecommerce", {})[:current_unit] || 'USD'
+    Plugins::Ecommerce::UtilService.ecommerce_money_to_cents(money)
   end
 
 end

data/app/models/plugins/ecommerce/attribute.rb

@@ -0,0 +1,9 @@
+class Plugins::Ecommerce::Attribute < ActiveRecord::Base
+  self.table_name='plugins_ecommerce_attributes'
+  belongs_to :site
+  has_many :values, class_name: 'Plugins::Ecommerce::Attribute', foreign_key: :parent_id, dependent: :destroy
+  belongs_to :product_attribute, class_name: 'Plugins::Ecommerce::Attribute', foreign_key: :parent_id
+  scope :only_group, ->{ where(parent_id: nil) }
+  scope :only_value, ->{ where.not(parent_id: nil) }
+  default_scope ->{ order(position: :ASC) }
+end

data/app/models/plugins/ecommerce/cart.rb

@@ -1,11 +1,3 @@
-=begin
-  Camaleon CMS is a content management system
-  Copyright (C) 2015 by Owen Peredo Diaz
-  Email: owenperedo@gmail.com
-  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
-  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 Affero General Public License (GPLv3) for more details.
-=end
 class Plugins::Ecommerce::Cart < ActiveRecord::Base
   self.table_name = 'plugins_ecommerce_orders'
   default_scope { where(kind: 'cart') }
@@ -16,25 +8,23 @@ class Plugins::Ecommerce::Cart < ActiveRecord::Base
 
   belongs_to :site, :class_name => "CamaleonCms::Site", foreign_key: :site_id
   belongs_to :user, :class_name => "CamaleonCms::User", foreign_key: :user_id
+  scope :active_cart, ->{ where("#{Plugins::Ecommerce::Cart.table_name}.updated_at >= ?", 24.hours.ago) }
+
   after_create :generate_slug
 
-  def add_product(product, qty = 1)
-    pi = product_items.where(product_id: product.id).first
+  def add_product(product, qty = 1, variation_id = nil)
+    pi = product_items.where(product_id: product.id, variation_id: variation_id).first
     if pi.present?
       pi.update_column(:qty, qty)
     else
-      pi = product_items.create(product_id: product.id, qty: qty)
+      pi = product_items.create(product_id: product.id, qty: qty, variation_id: variation_id)
     end
     pi
   end
 
-  def remove_product(product_id)
-    product_items.where(product_id: product_id).destroy_all
-  end
-
   # return the product titles in array format
   def products_title
-    products.decorate.each{|p| p.the_title }.join(', ')
+    product_items.map{|i| p=i.product.decorate; p.the_variation_title(i.variation_id) }.join(', ')
   end
 
   def items_total
@@ -43,16 +33,15 @@ class Plugins::Ecommerce::Cart < ActiveRecord::Base
 
   # price of all products (no include taxes)
   def sub_total
-    # product_items.map{|item| product = item.product.decorate; (product.price + product.tax) * item.qty }.inject{|sum,x| sum + x } || 0
-    product_items.map{|item| product = item.product.decorate; (product.price) * item.qty }.inject{|sum,x| sum + x } || 0
+    product_items.map{|item| product = item.product.decorate; (product.price(item.variation_id)) * item.qty }.inject{|sum,x| sum + x } || 0
   end
 
   def tax_total
-    product_items.map{|item| product = item.product.decorate; (product.tax) * item.qty }.inject{|sum,x| sum + x } || 0
+    product_items.map{|item| product = item.product.decorate; (product.tax(item.variation_id)) * item.qty }.inject{|sum,x| sum + x } || 0
   end
 
   def weight_total
-    product_items.map{|item| product = item.product.decorate; (product.weight) * item.qty }.inject{|sum,x| sum + x } || 0
+    product_items.map{|item| product = item.product.decorate; (product.weight(item.variation_id)) * item.qty }.inject{|sum,x| sum + x } || 0
   end
 
   # verify an return {error: (error code), discount: amount of discount} coupon for current cart
@@ -72,8 +61,10 @@ class Plugins::Ecommerce::Cart < ActiveRecord::Base
         res[:error] = 'required_minimum_price'
       else
         case opts[:discount_type]
-          when 'free_ship'
+          when 'free'
             res[:discount] = price || sub_total
+          when 'free_ship'
+            res[:discount] = total_shipping
           when 'percent'
             res[:discount] = sub_total * opts[:amount].to_f / 100
           when 'money'
@@ -86,8 +77,17 @@ class Plugins::Ecommerce::Cart < ActiveRecord::Base
     res
   end
 
+  def prepare_to_pay
+    self.class.transaction do
+      self.update_columns(
+        status: 'qtys_taken',
+      )
+      self.product_items.decorate.each{|p_item| p_item.decrement_qty! }
+    end
+  end
+
   # convert into order current cart
-  def make_order!
+  def convert_to_order
     self.update_columns(kind: 'order', created_at: Time.current)
     site.orders.find(self.id)
   end
@@ -137,23 +137,41 @@ class Plugins::Ecommerce::Cart < ActiveRecord::Base
     total_amount <= 0
   end
 
-  # return order object
-  def make_paid!(status = 'paid')
+  def update_amounts
     product_items.decorate.each do |item|
       p = item.product.decorate
-      item.update_columns(cache_the_price: item.the_price, cache_the_title: p.the_title, cache_the_tax: p.the_tax, cache_the_sub_total: item.the_sub_total)
+      item.update_columns(
+        cache_the_price: p.the_price(item.variation_id),
+        cache_the_title: p.the_variation_title(item.variation_id),
+        cache_the_tax: p.the_tax(item.variation_id),
+        cache_the_sub_total: item.the_sub_total,
+      )
     end
 
     if self.coupon.present?
       res_coupon = self.discount_for(self.coupon, total_to_pay_without_discounts)
       unless res_coupon[:error].present?
-        update_columns(the_coupon_amount: res_coupon[:coupon].decorate.the_amount, coupon_amount: res_coupon[:discount])
+        update_columns(the_coupon_amount: res_coupon[:coupon].decorate.the_amount)
         res_coupon[:coupon].mark_as_used(user)
       end
     end
     c = self.decorate
-    self.update_columns(status: status, paid_at: Time.current, amount: total_amount, cache_the_total: c.the_price, cache_the_sub_total: c.the_sub_total, cache_the_tax: c.the_tax_total, cache_the_weight: c.the_weight_total, cache_the_discounts: c.the_total_discounts, cache_the_shipping: c.the_total_shipping)
-    make_order!
+    self.update_columns(
+      amount: total_amount,
+      cache_the_total: c.the_price,
+      cache_the_sub_total: c.the_sub_total,
+      cache_the_tax: c.the_tax_total,
+      cache_the_weight: c.the_weight_total,
+      cache_the_discounts: c.the_total_discounts,
+      cache_the_shipping: c.the_total_shipping,
+    )
+  end
+  
+  def mark_paid(status = 'paid')
+    self.update_columns(
+      status: status,
+      paid_at: Time.current,
+    )
   end
 
 

data/app/models/plugins/ecommerce/coupon.rb

@@ -1,11 +1,3 @@
-=begin
-  Camaleon CMS is a content management system
-  Copyright (C) 2015 by Owen Peredo Diaz
-  Email: owenperedo@gmail.com
-  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
-  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 Affero General Public License (GPLv3) for more details.
-=end
 class Plugins::Ecommerce::Coupon < CamaleonCms::TermTaxonomy
   default_scope { where(taxonomy: :ecommerce_coupon) }
   belongs_to :site, :class_name => "CamaleonCms::Site", foreign_key: :parent_id

data/app/models/plugins/ecommerce/legacy_cart.rb

@@ -0,0 +1,50 @@
+class Plugins::Ecommerce::LegacyCart < CamaleonCms::TermTaxonomy
+  default_scope { where(taxonomy: :ecommerce_cart) }
+  has_many :products, foreign_key: :objectid, through: :term_relationships, :source => :objects
+  belongs_to :site, :class_name => "CamaleonCms::Site", foreign_key: :parent_id
+
+  def add_product(object)
+    post_id = defined?(object.id) ? object.id : object.to_i
+    term_relationships.where(objectid: post_id).first_or_create if post_id > 0
+  end
+
+  # update or set product quantity
+  # return true if it is possible to add the quantity
+  # return false if quantity is not enough
+  def set_product_qty(product, qty)
+    _options = self.get_option("product_#{product.id}")
+    if qty.to_f <= product.the_qty_real.to_f
+      _options['qty'] = qty
+      self.set_option("product_#{product.id}", _options)
+      true
+    else
+      false
+    end
+  end
+
+  def remove_product(object)
+    post_id = defined?(object.id) ? object.id : object.to_i
+    term_relationships.where(objectid: post_id).destroy_all if post_id > 0
+  end
+
+  def the_items_count
+    options.map{|k, p| p[:qty].to_i}.inject{|sum,x| sum + x } || 0 rescue 0
+  end
+
+  def the_amount_total
+    options.map{|k, p| (p[:price].to_f + p[:tax])* p[:qty].to_f}.inject{|sum,x| sum + x } || 0 rescue 0
+  end
+
+  # return the price of current cart ($10)
+  def the_price
+    "#{self.site.decorate.current_unit}#{sprintf('%.2f', the_amount_total)}"
+  end
+
+  # set user in filter
+  def self.set_user(user)
+    user_id = defined?(user.id) ? user.id : user.to_i
+    self.where(user_id: user_id)
+  end
+
+
+end

data/app/models/plugins/ecommerce/legacy_order.rb

@@ -0,0 +1,48 @@
+class Plugins::Ecommerce::LegacyOrder < CamaleonCms::TermTaxonomy
+  default_scope { where(taxonomy: :ecommerce_order) }
+  has_one :details, class_name: "Plugins::Ecommerce::OrderDetail", foreign_key: :order_id, dependent: :destroy
+  has_many :products, foreign_key: :objectid, through: :term_relationships, :source => :objects
+  belongs_to :customer, class_name: "CamaleonCms::User", foreign_key: :user_id
+
+  def add_product(object)
+    post_id = defined?(object.id) ? object.id : object.to_i
+    term_relationships.where(objectid: post_id).first_or_create if post_id > 0
+  end
+  def remove_product(object)
+    post_id = defined?(object.id) ? object.id : object.to_i
+    term_relationships.where(objectid: post_id).destroy_all if post_id > 0
+  end
+
+  def payment_method
+    Plugins::Ecommerce::PaymentMethod.find_by_id get_meta("payment")[:payment_id]
+  end
+
+  def payment
+    payment = get_meta("payment")
+    get_meta("pay_#{payment[:type]}".to_sym)
+  end
+
+  def shipping_method
+    Plugins::Ecommerce::ShippingMethod.find_by_id get_meta("payment", {})[:shipping_method]
+  end
+
+  def canceled?
+    status == 'canceled'
+  end
+  def unpaid?
+    status == 'unpaid'
+  end
+
+  def paid?
+    payment.present?
+  end
+
+
+  # set user in filter
+  def self.set_user(user)
+    user_id = defined?(user.id) ? user.id : user.to_i
+    self.where(user_id: user_id)
+  end
+
+
+end

data/app/models/plugins/ecommerce/order.rb

@@ -1,11 +1,3 @@
-=begin
-  Camaleon CMS is a content management system
-  Copyright (C) 2015 by Owen Peredo Diaz
-  Email: owenperedo@gmail.com
-  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
-  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 Affero General Public License (GPLv3) for more details.
-=end
 class Plugins::Ecommerce::Order < Plugins::Ecommerce::Cart
   self.table_name = 'plugins_ecommerce_orders'
   has_many :metas, ->{ where(object_class: 'Plugins::Ecommerce::Cart')}, :class_name => "CamaleonCms::Meta", foreign_key: :objectid, dependent: :delete_all

data/app/models/plugins/ecommerce/order_detail.rb

@@ -1,13 +1,4 @@
-=begin
-  Camaleon CMS is a content management system
-  Copyright (C) 2015 by Owen Peredo Diaz
-  Email: owenperedo@gmail.com
-  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
-  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 Affero General Public License (GPLv3) for more details.
-=end
 class Plugins::Ecommerce::OrderDetail < ActiveRecord::Base
   self.table_name = "plugins_order_details"
-  attr_accessible :order_id, :customer, :email, :phone, :status, :received_at, :accepted_at, :shipped_at, :closed_at
   belongs_to :order, class_name: "Plugins::Ecommerce::Order", foreign_key: :order_id
 end

data/app/models/plugins/ecommerce/payment_method.rb

@@ -1,11 +1,3 @@
-=begin
-  Camaleon CMS is a content management system
-  Copyright (C) 2015 by Owen Peredo Diaz
-  Email: owenperedo@gmail.com
-  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
-  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 Affero General Public License (GPLv3) for more details.
-=end
 class Plugins::Ecommerce::PaymentMethod < CamaleonCms::TermTaxonomy
   default_scope { where(taxonomy: :ecommerce_payment_method) }
   belongs_to :site, :class_name => "CamaleonCms::Site", foreign_key: :parent_id

data/app/models/plugins/ecommerce/product_item.rb

@@ -1,20 +1,13 @@
-=begin
-  Camaleon CMS is a content management system
-  Copyright (C) 2015 by Owen Peredo Diaz
-  Email: owenperedo@gmail.com
-  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
-  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 Affero General Public License (GPLv3) for more details.
-=end
 class Plugins::Ecommerce::ProductItem < ActiveRecord::Base
   include CamaleonCms::Metas
   self.table_name = 'plugins_ecommerce_products'
-  belongs_to :cart, class_name: 'Plugins::Ecommerce::Cart', foreign_key: :order_id
+  belongs_to :cart, class_name: 'Plugins::Ecommerce::Cart', foreign_key: :order_id, touch: true
   belongs_to :order, class_name: 'Plugins::Ecommerce::Order'
   belongs_to :product, foreign_key: :product_id, class_name: 'CamaleonCms::Post'
+  belongs_to :product_variation, class_name: 'Plugins::Ecommerce::ProductVariation', foreign_key: :variation_id
 
   def sub_total
     p = self.product.decorate
-    (p.price + p.tax) * self.qty
+    (p.price(self.variation_id) + p.tax(self.variation_id)) * self.qty
   end
 end

data/app/models/plugins/ecommerce/product_variation.rb

@@ -0,0 +1,9 @@
+class Plugins::Ecommerce::ProductVariation < ActiveRecord::Base
+  self.table_name='plugins_ecommerce_product_variations'
+  belongs_to :product, class_name: "CamaleonCms::Post"
+
+  # return all attribute values assigned to this product
+  def attribute_values
+    Plugins::Ecommerce::Attribute.only_value.where(id: self.attribute_ids.to_s.split(','))
+  end
+end

data/app/models/plugins/ecommerce/shipping_method.rb

@@ -1,11 +1,3 @@
-=begin
-  Camaleon CMS is a content management system
-  Copyright (C) 2015 by Owen Peredo Diaz
-  Email: owenperedo@gmail.com
-  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
-  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 Affero General Public License (GPLv3) for more details.
-=end
 class Plugins::Ecommerce::ShippingMethod < CamaleonCms::TermTaxonomy
   default_scope { where(taxonomy: :ecommerce_shipping_method) }
   belongs_to :site, :class_name => "CamaleonCms::Site", foreign_key: :parent_id

data/app/models/plugins/ecommerce/tax_rate.rb

@@ -1,11 +1,3 @@
-=begin
-  Camaleon CMS is a content management system
-  Copyright (C) 2015 by Owen Peredo Diaz
-  Email: owenperedo@gmail.com
-  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
-  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 Affero General Public License (GPLv3) for more details.
-=end
 class Plugins::Ecommerce::TaxRate < CamaleonCms::TermTaxonomy
   default_scope { where(taxonomy: :ecommerce_tax_rate) }
   belongs_to :site, :class_name => "CamaleonCms::Site", foreign_key: :parent_id

data/app/services/plugins/ecommerce/cart_service.rb

@@ -0,0 +1,149 @@
+class Plugins::Ecommerce::CartService
+  def initialize(site, cart)
+    @site = site
+    @cart = cart
+  end
+
+  attr_reader :site, :cart
+
+  def pay_with_authorize_net(options={})
+    payment_method = options[:payment_method] || site_service.payment_method('authorize_net')
+    billing_address = cart.get_meta("billing_address")
+    details = cart.get_meta("details")
+    amount = Plugins::Ecommerce::UtilService.ecommerce_money_to_cents(cart.total_amount)
+    payment_params = {
+      order_id: cart.slug,
+      currency: site.currency_code,
+      email: cart.user.email,
+      billing_address: {name: "#{cart.user.fullname}",
+                           address1: billing_address[:address1],
+                           address2: billing_address[:address2],
+                           city: billing_address[:city],
+                           state: billing_address[:state],
+                           country: billing_address[:country],
+                           zip: billing_address[:zip]
+      },
+      description: 'Buy Products',
+      ip: options[:ip]
+    }
+
+    if options[:ip]
+      payment_params[:ip] = options[:ip]
+    end
+
+    authorize_net_options = {
+      login: payment_method.options[:authorize_net_login_id],
+      password: payment_method.options[:authorize_net_transaction_key]
+    }
+
+    ActiveMerchant::Billing::Base.mode = payment_method.options[:authorize_net_sandbox].to_s.to_bool ? :test : :production
+
+    credit_card = ActiveMerchant::Billing::CreditCard.new(
+      first_name: options[:first_name],
+      last_name: options[:last_name],
+      number: options[:number],
+      month: options[:exp_month],
+      year: "20#{options[:exp_year]}",
+      verification_value: options[:cvc]
+    )
+    if credit_card.validate.empty?
+      gateway = ActiveMerchant::Billing::AuthorizeNetGateway.new(authorize_net_options)
+      response = gateway.purchase(amount, credit_card, payment_params)
+      if response.success?
+        cart.set_meta('pay_authorize_net', payment_params)
+        return {}
+      else
+        return {error: response.message}
+      end
+    else
+      return {error: credit_card.validate.map{|k, v| "#{k}: #{v.join(', ')}"}.join('<br>')}
+    end
+  end
+
+  def pay_with_paypal(options={})
+    payment_method = options[:payment_method] || site_service.payment_method('paypal')
+    billing_address = cart.get_meta("billing_address")
+    ActiveMerchant::Billing::Base.mode = payment_method.options[:paypal_sandbox].to_s.to_bool ? :test : :production
+    paypal_options = {
+      login: payment_method.options[:paypal_login],
+      password: payment_method.options[:paypal_password],
+      signature: payment_method.options[:paypal_signature]
+    }
+    gateway = ActiveMerchant::Billing::PaypalExpressGateway.new(paypal_options)
+    amount_in_cents = Plugins::Ecommerce::UtilService.ecommerce_money_to_cents(cart.total_amount)
+    gateway_request = {
+      brand_name: site.name,
+      items: [{
+        number: cart.slug,
+        name: "Buy Products from #{site.the_title}: #{cart.products_title}",
+        amount: amount_in_cents,
+      }],
+      order_id: cart.slug,
+      currency: site.currency_code,
+      email: cart.user.email,
+      billing_address: {name: "#{billing_address[:first_name]} #{billing_address[:last_name]}",
+                           address1: billing_address[:address1],
+                           address2: billing_address[:address2],
+                           city: billing_address[:city],
+                           state: billing_address[:state],
+                           country: billing_address[:country],
+                           zip: billing_address[:zip]
+      },
+      description: "Buy Products from #{site.the_title}: #{cart.total_amount}",
+      ip: options[:ip],
+      return_url: options[:return_url],
+      cancel_return_url: options[:cancel_return_url]
+    }
+
+    if options[:ip]
+      gateway_request[:ip] = options[:ip]
+    end
+
+    response = gateway.setup_purchase(amount_in_cents, gateway_request)
+    # TODO handle errors
+    {redirect_url: gateway.redirect_url_for(response.token)}
+  end
+
+  def pay_with_stripe(options)
+    require 'stripe'
+    payment_method = options[:payment_method] || site_service.payment_method('stripe')
+    Stripe.api_key = payment_method.options[:stripe_id]
+    customer = Stripe::Customer.create(
+      email: options[:email], source: options[:stripe_token])
+    amount_in_cents = Plugins::Ecommerce::UtilService.ecommerce_money_to_cents(cart.total_amount)
+    begin
+      charge = Stripe::Charge.create(
+        customer: customer.id,
+        amount: amount_in_cents,
+        description: "Payment Products: #{cart.products_title}",
+        currency: site_service.currency,
+      )
+      payment_data = {
+        email: options[:email],
+        customer: customer.id,
+        charge: charge.id,
+      }
+      cart.set_meta("payment_data", payment_data)
+      {}
+    rescue Stripe::CardError => e
+      {error: e.message, payment_error: true}
+    rescue => e
+      {error: e.message}
+    end
+  end
+
+  def convert_to_order(status = 'paid')
+    Plugins::Ecommerce::Cart.transaction do
+      cart.prepare_to_pay
+      cart.update_amounts
+      cart.mark_paid(status)
+      cart.convert_to_order
+    end
+  end
+
+  private
+
+  def site_service
+    @site_service ||= Plugins::Ecommerce::SiteService.new(site)
+  end
+end