effective_orders 1.0.0

data/app/mailers/effective/orders_mailer.rb

@@ -0,0 +1,64 @@
+module Effective
+  class OrdersMailer < ActionMailer::Base
+    helper EffectiveOrdersHelper
+
+    default :from => EffectiveOrders.mailer[:default_from]
+
+    def order_receipt_to_admin(order)
+      @order = order
+      mail(:to => EffectiveOrders.mailer[:admin_email], :subject => receipt_to_admin_subject(order))
+    end
+
+    def order_receipt_to_buyer(order)  # Buyer
+      @order = order
+      mail(:to => order.user.email, :subject => receipt_to_buyer_subject(order))
+    end
+
+    def order_receipt_to_seller(order, seller, order_items)
+      @order = order
+      @user = seller.user
+      @order_items = order_items
+
+      mail(:to => @user.email, :subject => receipt_to_seller_subject(order, order_items, seller.user))
+    end
+
+    private
+
+    def receipt_to_admin_subject(order)
+      string_or_callable = EffectiveOrders.mailer[:subject_for_admin_receipt]
+
+      if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
+        string_or_callable = self.instance_exec(order, &string_or_callable)
+      end
+
+      prefix_subject(string_or_callable.presence || "Order ##{order.to_param} Receipt")
+    end
+
+    def receipt_to_buyer_subject(order)
+      string_or_callable = EffectiveOrders.mailer[:subject_for_buyer_receipt]
+
+      if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
+        string_or_callable = self.instance_exec(order, &string_or_callable)
+      end
+
+      prefix_subject(string_or_callable.presence || "Order ##{order.to_param} Receipt")
+    end
+
+    def receipt_to_seller_subject(order, order_items, seller)
+      string_or_callable = EffectiveOrders.mailer[:subject_for_seller_receipt]
+
+      if string_or_callable.respond_to?(:call) # This is a Proc or a function, not a string
+        string_or_callable = self.instance_exec(order, order_items, seller, &string_or_callable)
+      end
+
+      prefix_subject(string_or_callable.presence || "#{order_items.count} of your products #{order_items.count > 1 ? 'have' : 'has'} been purchased")
+    end
+
+    def prefix_subject(text)
+      prefix = (EffectiveOrders.mailer[:subject_prefix].to_s rescue '')
+      prefix.present? ? (prefix.chomp(' ') + ' ' + text) : text
+    end
+
+  end
+end
+

data/app/models/concerns/acts_as_purchasable.rb

@@ -0,0 +1,134 @@
+module ActsAsPurchasable
+  extend ActiveSupport::Concern
+
+  module ActiveRecord
+    def acts_as_purchasable(*options)
+      @acts_as_purchasable = options || []
+      include ::ActsAsPurchasable
+    end
+  end
+
+  included do
+    has_many :orders, :through => :order_items, :class_name => 'Effective::Order'
+    has_many :order_items, :as => :purchasable, :class_name => 'Effective::OrderItem'
+    has_many :cart_items, :as => :purchasable, :dependent => :delete_all, :class_name => 'Effective::CartItem'
+
+    validates_with Effective::SoldOutValidator, :on => :create
+
+    validates :price, :presence => true, :numericality => true
+    validates :tax_exempt, :inclusion => {:in => [true, false]}
+
+    # These are breaking on the check for quanitty_enabled?.  More research is due
+    validates :quantity_purchased, :numericality => {:allow_nil => true}, :if => proc { |purchasable| (purchasable.quantity_enabled? rescue false) }
+    validates :quantity_max, :numericality => {:allow_nil => true}, :if => proc { |purchasable| (purchasable.quantity_enabled? rescue false) }
+
+    scope :purchased, -> { joins(:order_items).joins(:orders).where(:orders => {:purchase_state => EffectiveOrders::PURCHASED}).uniq }
+    scope :purchased_by, lambda { |user| joins(:order_items).joins(:orders).where(:orders => {:user_id => user.try(:id), :purchase_state => EffectiveOrders::PURCHASED}).uniq }
+    scope :sold, -> { purchased() }
+    scope :sold_by, lambda { |user| joins(:order_items).joins(:orders).where(:order_items => {:seller_id => user.try(:id)}).where(:orders => {:purchase_state => EffectiveOrders::PURCHASED}).uniq }
+
+    scope :not_purchased, -> { where('id NOT IN (?)', purchased.pluck(:id).presence || [0]) }
+  end
+
+  module ClassMethods
+    def after_purchase(&block)
+      send :define_method, :after_purchase do |order, order_item| self.instance_exec(order, order_item, &block) end
+    end
+
+    def after_decline(&block)
+      send :define_method, :after_decline do |order, order_item| self.instance_exec(order, order_item, &block) end
+    end
+  end
+
+  # Regular instance methods
+  def is_effectively_purchasable?
+    true
+  end
+
+  def price
+    self[:price] || 0
+  end
+
+  # If I have a column type of Integer, and I'm passed a non-Integer, convert it here
+  def price=(value)
+    integer_column = ((column_for_attribute('price').try(:type) rescue nil) == :integer) # Rails built in method to lookup datatype
+
+    if integer_column == false
+      super
+    elsif value.kind_of?(Integer)
+      super
+    elsif value.kind_of?(String) && !value.include?('.') # Looks like an integer
+      super
+    else # Could be Float, BigDecimal, or String like 9.99
+      super((value.to_f * 100.0).to_i)
+    end
+  end
+
+  def title
+    self[:title] || 'ActsAsPurchasable'
+  end
+
+  def tax_exempt
+    self[:tax_exempt] || false
+  end
+
+  def tax_rate
+    @tax_rate ||= (
+      self.instance_exec(self, &EffectiveOrders.tax_rate_method).to_f.tap do |rate|
+        raise ArgumentError.new("expected EffectiveOrders.tax_rate_method to return a value between 0 and 1. Received #{rate}. Please return 0.05 for 5% tax.") if (rate > 1.0 || rate < 0.0)
+      end
+    )
+  end
+
+  def seller
+    if EffectiveOrders.stripe_connect_enabled
+      raise 'acts_as_purchasable object requires the seller be defined to return the User selling this item.  This is only a requirement when using StripeConnect.'
+    end
+  end
+
+  def purchased?
+    @is_purchased ||= orders.any? { |order| order.purchased? }
+  end
+
+  def purchased_by?(user)
+    orders.any? { |order| order.purchased? && order.user_id == user.id }
+  end
+
+  def purchased_orders
+    orders.select { |order| order.purchased? }
+  end
+
+  def quantity_enabled?
+    self.respond_to?(:quantity_enabled) ? quantity_enabled == true : false
+  end
+
+  def quantity_remaining
+    (quantity_max - quantity_purchased) rescue 0
+  end
+
+  def sold_out?
+    quantity_enabled? ? (quantity_remaining == 0) : false
+  end
+
+  def purchased!(order = nil, order_item = nil)
+    # begin
+    #   self.quantity_purchased = (self.quantity_purchased + 1)
+    # rescue
+    # end
+
+    after_purchase(order, order_item) if self.respond_to?(:after_purchase)
+    self.save!
+  end
+
+  def declined!(order = nil, order_item = nil)
+    after_decline(order, order_item) if self.respond_to?(:after_decline)
+    self.save!
+  end
+
+  # Override me if this is a digital purchase.
+  def purchased_download_url
+    false
+  end
+
+end
+

data/app/models/effective/access_denied.rb

@@ -0,0 +1,17 @@
+unless defined?(Effective::AccessDenied)
+  module Effective
+    class AccessDenied < StandardError
+      attr_reader :action, :subject
+
+      def initialize(message = nil, action = nil, subject = nil)
+        @message = message
+        @action = action
+        @subject = subject
+      end
+
+      def to_s
+        @message || I18n.t(:'unauthorized.default', :default => 'Access Denied')
+      end
+    end
+  end
+end

data/app/models/effective/cart.rb

@@ -0,0 +1,65 @@
+module Effective
+  class Cart < ActiveRecord::Base
+    self.table_name = EffectiveOrders.carts_table_name.to_s
+
+    belongs_to :user    # This is optional.  We want to let non-logged-in people have carts too
+    has_many :cart_items, :inverse_of => :cart, :dependent => :delete_all
+
+    structure do
+      timestamps
+    end
+
+    default_scope -> { includes(:cart_items => :purchasable) }
+
+    def add(item, quantity = 1)
+      raise 'expecting an acts_as_purchasable object' unless item.respond_to?(:is_effectively_purchasable?)
+
+      existing_item = cart_items.where(:purchasable_id => item.id, :purchasable_type => item.class.name).first
+
+      if item.quantity_enabled? && (quantity + (existing_item.quantity rescue 0)) > item.quantity_remaining
+        raise EffectiveOrders::SoldOutException, "#{item.title} is sold out"
+        return
+      end
+
+      if existing_item.present?
+        existing_item.update_attributes(:quantity => existing_item.quantity + quantity)
+      else
+        cart_items.create(:cart => self, :purchasable_id => item.id, :purchasable_type => item.class.name, :quantity => quantity)
+      end
+    end
+    alias_method :add_to_cart, :add
+
+    def remove(obj)
+      (cart_items.find(cart_item) || cart_item).try(:destroy)
+    end
+    alias_method :remove_from_cart, :remove
+
+    def includes?(item)
+      find(item).present?
+    end
+
+    def find(item)
+      cart_items.to_a.find { |cart_item| cart_item == item || cart_item.purchasable == item }
+    end
+
+    def size
+      cart_items.size
+    end
+
+    def empty?
+      size == 0
+    end
+
+    def subtotal
+      cart_items.map(&:subtotal).sum
+    end
+
+    def tax
+      cart_items.map(&:tax).sum
+    end
+
+    def total
+      cart_items.map(&:total).sum
+    end
+  end
+end

data/app/models/effective/cart_item.rb

@@ -0,0 +1,40 @@
+module Effective
+  class CartItem < ActiveRecord::Base
+    self.table_name = EffectiveOrders.cart_items_table_name.to_s
+
+    belongs_to :cart
+    belongs_to :purchasable, :polymorphic => true
+
+    structure do
+      quantity    :integer, :validates => [:presence]
+      timestamps
+    end
+
+    validates_presence_of :purchasable
+
+    delegate :title, :tax_exempt, :tax_rate, :to => :purchasable
+
+    default_scope -> { order(:updated_at) }
+
+    def price
+      if (purchasable.price || 0).kind_of?(Integer)
+        purchasable.price || 0
+      else
+        ActiveSupport::Deprecation.warn('price is a non-integer. It should be an Integer representing the number of cents.  Continuing with (price * 100.0).floor conversion') unless EffectiveOrders.silence_deprecation_warnings
+        (purchasable.price * 100.0).floor rescue 0
+      end
+    end
+
+    def subtotal
+      price * quantity
+    end
+
+    def tax
+      tax_exempt ? 0 : (subtotal * tax_rate).ceil
+    end
+
+    def total
+      subtotal + tax
+    end
+  end
+end

data/app/models/effective/customer.rb

@@ -0,0 +1,61 @@
+module Effective
+  class Customer < ActiveRecord::Base
+    self.table_name = EffectiveOrders.customers_table_name.to_s
+
+    attr_accessor :token # This is a convenience method so we have a place to store StripeConnect temporary access tokens
+
+    belongs_to :user
+    has_many :subscriptions, :inverse_of => :customer
+
+    structure do
+      stripe_customer_id            :string  # cus_xja7acoa03
+      stripe_active_card            :string  # **** **** **** 4242 Visa 05/12
+      stripe_connect_access_token   :string  # If using StripeConnect and this user is a connected Seller
+
+      timestamps
+    end
+
+    validates_presence_of :user
+    validates_uniqueness_of :user_id  # Only 1 customer per user may exist
+
+    scope :customers, -> { where("#{EffectiveOrders.customers_table_name.to_s}.stripe_customer_id IS NOT NULL") }
+
+    class << self
+      def for_user(user)
+        if user.present?
+          Effective::Customer.where(:user_id => (user.try(:id) rescue user.to_i)).first_or_create
+        end
+      end
+    end
+
+    def stripe_customer
+      @stripe_customer ||= if stripe_customer_id.present?
+        ::Stripe::Customer.retrieve(stripe_customer_id)
+      else
+        ::Stripe::Customer.create(:email => user.email, :description => user.id.to_s).tap do |stripe_customer|
+          self.update_attributes(:stripe_customer_id => stripe_customer.id)
+        end
+      end
+    end
+
+    def update_card!(token)
+      if token.present? # Oh, so they want to use a new credit card...
+        stripe_customer.card = token  # This sets the default_card to the new card
+
+        if stripe_customer.save && stripe_customer.default_card.present?
+          card = stripe_customer.cards.retrieve(stripe_customer.default_card)
+
+          self.stripe_active_card = "**** **** **** #{card.last4} #{card.type} #{card.exp_month}/#{card.exp_year}"
+          self.save!
+        else
+          raise Exception.new('unable to update stripe customer with new card')
+        end
+      end
+    end
+
+    def is_stripe_connect_seller?
+      stripe_connect_access_token.present?
+    end
+
+  end
+end

data/app/models/effective/datatables/customers.rb

@@ -0,0 +1,45 @@
+if defined?(EffectiveDatatables)
+  module Effective
+    module Datatables
+      class Customers < Effective::Datatable
+        table_column :email, :column => 'users.email' do |user|
+          mail_to user.email, user.email
+        end
+
+        if EffectiveOrders.stripe_enabled
+          table_column :stripe_customer_id 
+          table_column :stripe_active_card
+        end
+
+        if EffectiveOrders.stripe_connect_enabled
+          table_column :stripe_connect_access_token 
+        end
+
+        table_column :subscription_types, :column => 'subscription_types'
+
+        table_column :actions, :sortable => false, :filter => false, :partial => '/admin/customers/actions'
+
+        def collection
+          Effective::Customer.customers.uniq
+            .joins(:user)
+            .joins(:subscriptions)
+            .select('customers.*')
+            .select('users.email AS email')
+            .select("array_to_string(array(#{Effective::Subscription.purchased.select('subscriptions.stripe_plan_id').where('subscriptions.customer_id = customers.id').to_sql}), ' ,') AS subscription_types")
+            .group('customers.id')
+            .group('subscriptions.stripe_plan_id')
+            .group('users.email')
+        end
+
+        def search_column(collection, table_column, search_term)
+          if table_column[:name] == 'subscription_types'
+            collection.where('subscriptions.stripe_plan_id ILIKE ?', "%#{search_term}%")
+          else
+            super
+          end
+        end
+
+      end
+    end
+  end
+end

data/app/models/effective/datatables/orders.rb

@@ -0,0 +1,53 @@
+if defined?(EffectiveDatatables)
+  module Effective
+    module Datatables
+      class Orders < Effective::Datatable
+        table_column :id do |order|
+          order.to_param
+        end
+
+        array_column :email, :label => 'Buyer', :if => Proc.new { attributes[:user_id].blank? } do |order|
+          link_to order.user.email, (edit_admin_user_path(order.user) rescue admin_user_path(order.user) rescue '#')
+        end
+
+        array_column :order_items do |order|
+          content_tag(:ul) do
+            order.order_items.map { |oi| content_tag(:li, oi.title) }.join().html_safe
+          end
+        end
+
+        table_column :purchased_at
+
+        array_column :total do |order|
+          price_to_currency(order.total)
+        end
+
+        table_column :actions, :sortable => false, :filter => false do |order|
+          content_tag(:span, :style => 'white-space: nowrap;') do
+            [
+              link_to('View', (datatables_admin_path? ? effective_orders.admin_order_path(order) : effective_orders.order_path(order))),
+              (link_to('Resend Receipt', effective_orders.resend_buyer_receipt_path(order), {'data-confirm' => 'This action will resend a copy of the original email receipt.  Send receipt now?'}) if order.try(:purchased?))
+            ].compact.join(' - ').html_safe
+          end
+        end
+
+        def collection
+          if attributes[:user_id].present?
+            Effective::Order.purchased.where(:user_id => attributes[:user_id]).includes(:user).includes(:order_items)
+          else
+            Effective::Order.purchased.includes(:user).includes(:order_items)
+          end
+        end
+
+        def search_column(collection, table_column, search_term)
+          if table_column[:name] == 'id'
+            collection.where(:id => search_term)
+          else
+            super
+          end
+        end
+
+      end
+    end
+  end
+end