tb_checkout 1.0.3

data/app/controllers/tb_checkout/carts_controller.rb

@@ -0,0 +1,8 @@
+class TbCheckout::CartsController < TbCheckout::ApplicationController
+
+  def show
+    @cart = tb_checkout_current_cart
+    respond_with @cart
+  end
+
+end

data/app/controllers/tb_checkout/transactions_controller.rb

@@ -0,0 +1,87 @@
+class TbCheckout::TransactionsController < TbCheckout::ApplicationController
+
+  before_action :load_cart, :only => [:new, :create, :confirm, :capture]
+
+  def index
+    @transactions = TbCheckout::Transaction.captured.for_user_or_session(current_user_id, session.id).includes(:cart => :cart_items).paginate(:page => params[:page], :per_page => 10)
+    respond_with @transactions
+  end
+
+  def new
+    @transaction = @cart.transactions.new()
+    if !Rails.env.production?
+      # These values will work against the Authorize.Net sandbox environment
+      @transaction.card_type = 'visa'
+      @transaction.card_number = 4007000000027
+      @transaction.card_ccv = 123
+      @transaction.card_expiration = Date.today.next_year
+    end
+  end
+
+  def create
+    @transaction = @cart.transactions.new(transaction_params)
+    if @transaction.save() && @transaction.authorize!
+      redirect_to confirm_tb_checkout_transaction_path(@transaction)
+    else
+      if @transaction.response
+        flash.now[:error] = @transaction.response.message
+      end
+      if @transaction.status == TbCheckout::Transaction::Status::FAIL
+        @transaction = TbCheckout::Transaction.new(transaction_params)
+      end
+      render 'new'
+    end
+  end
+
+  def confirm
+    @transaction = @cart.transactions.authorized.where(:id => params[:id]).first
+    if @transaction.blank?
+      redirect_to new_tb_checkout_transaction_path
+    else
+      render 'confirm'
+    end
+  end
+
+  def capture
+    @transaction = @cart.transactions.authorized.where(:id => params[:id]).first
+    if @transaction.blank?
+      redirect_to new_tb_checkout_transaction_path
+      return false
+    else
+      if @transaction.capture!
+        flash[:notice] = 'Thanks! Your payment was collected successfully'
+        redirect_to tb_checkout_transaction_path(@transaction)
+      else
+        flash.now[:error] = @transaction.response.message if @transaction.response
+        render 'confirm'
+      end
+    end
+  end
+
+  def show
+    @transaction = TbCheckout::Transaction.captured.find_by(:id => params[:id])
+    if @transaction.present? && @transaction.belongs_to?(user_id:current_user_id, session_id:session.id)
+      render 'show'
+    else
+      flash[:error] = 'The transaction you were looking for could not be found'
+      redirect_to tb_checkout_cart_path
+    end
+  end
+
+private
+
+  def transaction_params
+    params.require(:tb_checkout_transaction).permit(:card_type, :card_number, :card_ccv, :card_expiration, 
+      :billing_first_name, :billing_last_name, :billing_address_1, :billing_address_2, :billing_city, :billing_state, :billing_postal)
+  end
+
+  def load_cart
+    @cart = tb_checkout_current_cart
+    if @cart.blank? || @cart.is_empty?
+      flash[:error] = 'You cannot check out with an empty cart'
+      redirect_to tb_checkout_cart_path
+      return false
+    end
+  end
+
+end

data/app/helpers/tb_checkout/admin/carts_helper.rb

@@ -0,0 +1,13 @@
+module TbCheckout::Admin::CartsHelper
+
+  def tb_checkout_status_label_for_cart(cart)
+    if cart.is_completed?
+      content_tag :span, 'Complete', :class => 'label label-success'
+    elsif cart.is_abandoned?
+      content_tag :span, 'Abandoned', :class => 'label label-inverse'
+    else
+      content_tag :span, 'In Progress', :class => 'label label-warning'
+    end
+  end
+
+end

data/app/helpers/tb_checkout/admin/transactions_helper.rb

@@ -0,0 +1,16 @@
+module TbCheckout::Admin::TransactionsHelper
+
+ def tb_checkout_status_label_for_transaction(status)
+    if status == 'captured'
+      cls = 'success'
+    elsif status == 'fail'
+      cls = 'important'
+    elsif status == 'refunded' || status == 'voided'
+      cls = 'warning'
+    else
+      cls = 'default'
+    end
+    content_tag :span, status.titleize, :class => "label label-#{cls}"
+  end
+
+end

data/app/helpers/tb_checkout/application_helper.rb

@@ -0,0 +1,138 @@
+module TbCheckout
+  module ApplicationHelper
+
+    # Return a link to the user's shopping cart, with the number of items in the text
+    #
+    # * link_text: The text of the link. Defaults: "My Cart"
+    #
+    def tb_checkout_cart_link(link_text:'My Cart')
+      if tb_checkout_current_cart.present?
+        count = tb_checkout_current_cart.cart_items.count
+      else
+        count = 0
+      end
+      link_to "#{link_text} (#{count})", tb_checkout_cart_path, :class => 'tb-checkout-cart-link'
+    end
+
+    # Return a form used to add a product to the user's shopping cart
+    #
+    # * product: The product you wish to add. Should be an ActiveRecord model that conforms to TbCheckout::Purchasable
+    # * quantity: Whether to display a quantity picker. Defaults to false
+    # * submit_text: Text of the submit button. Default: "Add to Cart"
+    # * submit_class: CSS class of the submit button. Default: "btn btn-primary"
+    # 
+    def tb_checkout_add_to_cart(product, quantity: false, submit_text:'Add to Cart', submit_class:'btn btn-primary')
+      cart_item = TbCheckout::CartItem.new({
+        :item => product,
+        :quantity => 1
+      })
+      return form_for cart_item, :html => {:class => 'tb-checkout-add-to-cart-form'} do |f|
+        concat f.hidden_field :item_type
+        concat f.hidden_field :item_id
+        if quantity
+          concat f.number_field :quantity, {:class => 'tb-checkout-add-to-cart-quantity'}
+        else
+          concat f.hidden_field :quantity
+        end
+        concat f.submit submit_text, :class => "#{submit_class} tb-checkout-add-to-cart-submit"
+      end
+    end
+
+    # Return a list of states for use in a form select field
+    #
+    def tb_checkout_options_for_states()
+      us_states = [
+        ['Alabama', 'AL'],
+        ['Alaska', 'AK'],
+        ['Arizona', 'AZ'],
+        ['Arkansas', 'AR'],
+        ['California', 'CA'],
+        ['Colorado', 'CO'],
+        ['Connecticut', 'CT'],
+        ['Delaware', 'DE'],
+        ['District of Columbia', 'DC'],
+        ['Florida', 'FL'],
+        ['Georgia', 'GA'],
+        ['Hawaii', 'HI'],
+        ['Idaho', 'ID'],
+        ['Illinois', 'IL'],
+        ['Indiana', 'IN'],
+        ['Iowa', 'IA'],
+        ['Kansas', 'KS'],
+        ['Kentucky', 'KY'],
+        ['Louisiana', 'LA'],
+        ['Maine', 'ME'],
+        ['Maryland', 'MD'],
+        ['Massachusetts', 'MA'],
+        ['Michigan', 'MI'],
+        ['Minnesota', 'MN'],
+        ['Mississippi', 'MS'],
+        ['Missouri', 'MO'],
+        ['Montana', 'MT'],
+        ['Nebraska', 'NE'],
+        ['Nevada', 'NV'],
+        ['New Hampshire', 'NH'],
+        ['New Jersey', 'NJ'],
+        ['New Mexico', 'NM'],
+        ['New York', 'NY'],
+        ['North Carolina', 'NC'],
+        ['North Dakota', 'ND'],
+        ['Ohio', 'OH'],
+        ['Oklahoma', 'OK'],
+        ['Oregon', 'OR'],
+        ['Pennsylvania', 'PA'],
+        ['Puerto Rico', 'PR'],
+        ['Rhode Island', 'RI'],
+        ['South Carolina', 'SC'],
+        ['South Dakota', 'SD'],
+        ['Tennessee', 'TN'],
+        ['Texas', 'TX'],
+        ['Utah', 'UT'],
+        ['Vermont', 'VT'],
+        ['Virginia', 'VA'],
+        ['Washington', 'WA'],
+        ['West Virginia', 'WV'],
+        ['Wisconsin', 'WI'],
+        ['Wyoming', 'WY']
+      ]
+      if TbCheckout.config.canada_is_real
+        return {
+          'United States' => us_states,
+          'Canada' => [
+            ['Alberta', 'AB'],
+            ['British Columbia ', 'BC'],
+            ['Manitoba', 'MB'],
+            ['New Brunswick', 'NB'],
+            ['Newfoundland and Labrador', 'NL'],
+            ['Nova Scotia', 'NS'],
+            ['Northwest Territories', 'NT'],
+            ['Nunavut', 'NU'],
+            ['Ontario', 'ON'],
+            ['Prince Edward Island', 'PE'],
+            ['Quebec', 'QC'],
+            ['Saskatchewan', 'SK'],
+            ['Yukon', 'YT']
+          ]
+        }
+      else
+        return us_states
+      end
+    end
+
+    # Return a list of credit card types for use with a form select
+    #
+    def tb_checkout_credit_card_types()
+      types = [
+        ['Visa', 'visa'],
+        ['MasterCard', 'master'],
+        ['Discover', 'discover'],
+        ['American Express', 'american_express']
+      ]
+      types.select!{ |a, b|
+        TbCheckout.config.card_types.include?(b.to_sym)
+      }
+      return types
+    end
+
+  end
+end

data/app/helpers/tb_checkout/transactions_helper.rb

@@ -0,0 +1,2 @@
+module TbCheckout::TransactionsHelper
+end

data/app/models/concerns/tb_checkout/belongs_to_user_session.rb

@@ -0,0 +1,15 @@
+module TbCheckout::BelongsToUserSession
+  extend ActiveSupport::Concern
+
+  included do
+    belongs_to :spud_user
+    scope :for_user_or_session, ->(user_id, session_id){
+      where('(session_id = ?) OR (spud_user_id IS NOT NULL AND spud_user_id != 0 AND spud_user_id = ?)', session_id, user_id)
+    }
+  end
+
+  def belongs_to?(user_id:nil, session_id:nil)
+    return (self.session_id == session_id) || (self.spud_user_id.present? && self.spud_user_id == user_id)
+  end
+
+end

data/app/models/concerns/tb_checkout/purchasable.rb

@@ -0,0 +1,81 @@
+module TbCheckout::Purchasable
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :cart_items, :class_name => 'TbCheckout::CartItem', :as => :item
+    tb_checkout_quantity_is_editable(true)
+    tb_checkout_delete_on_removal(false)
+
+    include ActiveSupport::Callbacks
+    define_callbacks :capture
+    set_callback :capture, :after, :tb_checkout_after_capture!
+  end
+
+  module ClassMethods
+    attr_reader :quantity_is_editable, :after_capture, :delete_on_removal, :url_builder, :cart_detail_view
+
+    # Configure whether or not the given class of product should support multiple quantities
+    # * Default: true
+    #
+    def tb_checkout_quantity_is_editable(is_editable)
+      @quantity_is_editable = is_editable
+    end
+
+    # Configure a hook to run after the corresponding transaction is successfully captured
+    # Use this to perform any cleanup tasks on the product model
+    #
+    # Ex:
+    #   tb_checkout_after_capture ->(instance){
+    #     instance.update_column(:is_captured, true)
+    #   }
+    #
+    def tb_checkout_after_capture(symbol_or_lambda)
+      @after_capture = symbol_or_lambda
+    end
+
+    # Configure whether or not the given class of product should self destruct when it is removed from the shopping cart
+    # For example, this may make sense for a purchasable record that is only used one time
+    # * Default: false
+    #
+    def tb_checkout_delete_on_removal(should_delete)
+      @delete_on_removal = should_delete
+    end
+
+    # Configure a callback that builds a URL for the given product page
+    # 
+    # Ex:
+    #   tb_checkout_url_builder ->(instance, context){
+    #     context.widget_path(instance.id)
+    #   }
+    def tb_checkout_url_builder(symbol_or_lambda)
+      @url_builder = symbol_or_lambda
+    end
+
+    # Configure a partial to be displayed in the shopping cart
+    #
+    def tb_checkout_cart_detail_view(detail_view)
+      @cart_detail_view = detail_view
+    end
+  end
+
+  def tb_checkout_build_url(view)
+    url_builder = self.class.url_builder
+    if url_builder.is_a? Proc
+      return url_builder.call(self, view)
+    elsif url_builder.is_a? Symbol
+      return send(url_builder, view)
+    end
+  end
+
+private
+
+  def tb_checkout_after_capture!
+    after_capture = self.class.after_capture
+    if after_capture.is_a? Proc
+      after_capture.call(self)
+    elsif after_capture.is_a? Symbol  
+      send(after_capture)
+    end
+  end
+
+end

data/app/models/tb_checkout/basic_product.rb

@@ -0,0 +1,6 @@
+module TbCheckout
+  class BasicProduct < ActiveRecord::Base
+    self.table_name = 'tb_checkout_basic_products'
+    include TbCheckout::Purchasable
+  end
+end

data/app/models/tb_checkout/cart.rb

@@ -0,0 +1,56 @@
+module TbCheckout
+  class Cart < ActiveRecord::Base
+    self.table_name = 'tb_checkout_carts'
+    has_many :cart_items, :inverse_of => :cart
+    has_many :transactions, :inverse_of => :cart
+
+    scope :completed, ->{ where(:is_completed => true) }
+    scope :in_progress, ->{ where(:is_completed => false, :is_abandoned => false) }
+    scope :abandoned, ->{ where(:is_abandoned => true) }
+
+    include TbCheckout::BelongsToUserSession
+
+    # Look for carts that have outlived the configured TbCheckout.config.cart_lifespan value and mark them as abandoned
+    #
+    def self.check_abandoned!
+      carts = in_progress.where('updated_at < ?', DateTime.now - TbCheckout.config.cart_lifespan)
+      return carts.update_all(:is_abandoned => true)
+    end
+
+    # Build a short description of the cart contents
+    #
+    def description
+      if cart_items.length == 0
+        desc = "This cart is currently empty"
+      elsif cart_items.length > 1
+        desc = "#{cart_items.first.item_description} and #{cart_items.length-1} other #{'item'.pluralize(cart_items.length-1)}"
+      else
+        desc = cart_items.first.item_description
+      end
+      return desc
+    end
+
+    def total_price
+      return self.cart_items.collect(&:total_price).sum()
+    end
+
+    def add_to_cart(product, quantity: 1)
+      if !product.class.included_modules.map(&:to_s).include?("TbCheckout::Purchasable")
+        raise ArgumentError, 'product must conform to TbCheckout::Purchasable'
+      end
+      return self.cart_items.create({
+        :item => product,
+        :quantity => quantity
+      })
+    end
+
+    def is_empty?
+      return self.cart_items.count == 0
+    end
+
+    def user_full_name
+      return self.spud_user.try(:full_name) || 'Anonymous'
+    end
+
+  end
+end

data/app/models/tb_checkout/cart_item.rb

@@ -0,0 +1,48 @@
+module TbCheckout
+  class CartItem < ActiveRecord::Base
+    self.table_name = 'tb_checkout_cart_items'
+    belongs_to :cart, :inverse_of => :cart_items, :touch => true
+    belongs_to :item, :polymorphic => true
+
+    validates :cart, :item, :presence => true
+    validates :quantity, :numericality => {:greater_than => 0}
+    before_save :set_item_values
+    after_destroy :cleanup_purchasable_item
+
+    def total_price
+      return item_price * quantity
+    end
+
+    def has_item_url?
+      return self.item && self.item.class.url_builder.present?
+    end
+
+    def item_url(view)
+      return item.tb_checkout_build_url(view)
+    end
+
+    def has_detail_view?
+      return self.item && self.item.class.cart_detail_view.present?
+    end
+
+    def detail_view
+      return self.item.class.cart_detail_view
+    end
+
+private
+
+    def set_item_values
+      if self.item
+        self.item_description = self.item.description
+        self.item_price = self.item.price
+      end
+    end
+
+    def cleanup_purchasable_item
+      if self.item && self.item.class.delete_on_removal
+        self.item.destroy()
+      end
+    end
+
+  end
+end