effective_orders 1.0.0

data/app/models/effective/order.rb

@@ -0,0 +1,247 @@
+module Effective
+  class Order < ActiveRecord::Base
+    self.table_name = EffectiveOrders.orders_table_name.to_s
+
+    if EffectiveOrders.obfuscate_order_ids
+      acts_as_obfuscated :format => '###-####-###'
+    end
+
+    acts_as_addressable :billing => EffectiveOrders.require_billing_address, :shipping => EffectiveOrders.require_shipping_address
+    attr_accessor :save_billing_address, :save_shipping_address, :shipping_address_same_as_billing # save these addresses to the user if selected
+
+    belongs_to :user  # This is the user who purchased the order
+    has_many :order_items, :inverse_of => :order
+
+    structure do
+      payment         :text   # serialized hash, see below
+      purchase_state  :string, :validates => [:inclusion => {:in => [nil, EffectiveOrders::PURCHASED, EffectiveOrders::DECLINED]}]
+      purchased_at    :datetime, :validates => [:presence => {:if => Proc.new { |order| order.purchase_state == EffectiveOrders::PURCHASED}}]
+
+      timestamps
+    end
+
+    accepts_nested_attributes_for :order_items, :allow_destroy => false, :reject_if => :all_blank
+    accepts_nested_attributes_for :user, :allow_destroy => false, :update_only => true
+
+    unless EffectiveOrders.skip_user_validation
+      validates_presence_of :user_id
+      validates_associated :user
+    end
+
+    if ((minimum_charge = EffectiveOrders.minimum_charge.to_i) rescue nil).present?
+      if EffectiveOrders.allow_free_orders
+        validates_numericality_of :total, :greater_than_or_equal_to => minimum_charge, :unless => Proc.new { |order| order.total == 0 }, :message => "A minimum order of #{EffectiveOrders.minimum_charge} is required.  Please add additional items to your cart."
+      else
+        validates_numericality_of :total, :greater_than_or_equal_to => minimum_charge, :message => "A minimum order of #{EffectiveOrders.minimum_charge} is required.  Please add additional items to your cart."
+      end
+    end
+
+    validates_presence_of :order_items, :message => 'No items are present.  Please add one or more item to your cart.'
+    validates_associated :order_items
+
+    serialize :payment, Hash
+
+    default_scope -> { includes(:user).includes(:order_items => :purchasable).order('created_at DESC') }
+
+    scope :purchased, -> { where(:purchase_state => EffectiveOrders::PURCHASED) }
+    scope :purchased_by, lambda { |user| purchased.where(:user_id => user.try(:id)) }
+    scope :declined, -> { where(:purchase_state => EffectiveOrders::DECLINED) }
+
+    def initialize(cart = {}, user = nil)
+      super() # Call super with no arguments
+
+      # Set up defaults
+      self.save_billing_address = true
+      self.save_shipping_address = true
+      self.shipping_address_same_as_billing = true
+
+      add_to_order(cart) if cart.present?
+
+      self.user = user if user.present?
+    end
+
+    def add(item, quantity = 1)
+      raise 'unable to alter a purchased order' if purchased?
+      raise 'unable to alter a declined order' if declined?
+
+      if item.kind_of?(Effective::Cart)
+        cart_items = item.cart_items
+      else
+        purchasables = [item].flatten
+
+        if purchasables.any? { |p| !p.respond_to?(:is_effectively_purchasable?) }
+          raise ArgumentError.new('Effective::Order.add() expects a single acts_as_purchasable item, or an array of acts_as_purchasable items')
+        end
+
+        cart_items = purchasables.map do |purchasable|
+          CartItem.new(:quantity => quantity).tap { |cart_item| cart_item.purchasable = purchasable }
+        end
+      end
+
+      retval = cart_items.map do |item|
+        order_items.build(
+          :title => item.title,
+          :quantity => item.quantity,
+          :price => item.price,
+          :tax_exempt => item.tax_exempt,
+          :tax_rate => item.tax_rate,
+          :seller_id => (item.purchasable.try(:seller).try(:id) rescue nil)
+        ).tap { |order_item| order_item.purchasable = item.purchasable }
+      end
+
+      retval.size == 1 ? retval.first : retval
+    end
+    alias_method :add_to_order, :add
+
+    def user=(user)
+      super
+
+      self.billing_address = user.billing_address if user.respond_to?(:billing_address)
+      self.shipping_address = user.shipping_address if user.respond_to?(:shipping_address)
+    end
+
+    # This is used for updating Subscription codes.
+    # We want to update the underlying purchasable object of an OrderItem
+    # Passing the order_item_attributes using rails default acts_as_nested creates a new object instead of updating the temporary one.
+    # So we override this method to do the updates on the non-persisted OrderItem objects
+    # Right now strong_paramaters only lets through stripe_coupon_id
+    # {"0"=>{"class"=>"Effective::Subscription", "stripe_coupon_id"=>"50OFF", "id"=>"2"}}}
+    def order_items_attributes=(order_item_attributes)
+      if self.persisted? == false
+        (order_item_attributes || {}).each do |_, atts|
+          order_item = self.order_items.find { |oi| oi.purchasable.class.name == atts[:class] && oi.purchasable.id == atts[:id].to_i }
+
+          if order_item
+            order_item.purchasable.attributes = atts.except(:id, :class)
+
+            # Recalculate the OrderItem based on the updated purchasable object
+            order_item.title = order_item.purchasable.title
+            order_item.price = order_item.purchasable.price
+            order_item.tax_exempt = order_item.purchasable.tax_exempt
+            order_item.tax_rate = order_item.purchasable.tax_rate
+            order_item.seller_id = (order_item.purchasable.try(:seller).try(:id) rescue nil)
+          end
+        end
+      end
+    end
+
+    def total
+      [order_items.map(&:total).sum, 0].max
+    end
+
+    def subtotal
+      order_items.map(&:subtotal).sum
+    end
+
+    def tax
+      [order_items.map(&:tax).sum, 0].max
+    end
+
+    def num_items
+      order_items.map(&:quantity).sum
+    end
+
+    def save_billing_address?
+      ::ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(self.save_billing_address)
+    end
+
+    def save_shipping_address?
+      ::ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(self.save_shipping_address)
+    end
+
+    def shipping_address_same_as_billing?
+      if self.shipping_address_same_as_billing.nil?
+        true # Default value
+      else
+        ::ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(self.shipping_address_same_as_billing)
+      end
+    end
+
+    # :validate => false, :email => false
+    def purchase!(payment_details = nil, opts = {})
+      opts = {:validate => true, :email => true}.merge(opts)
+
+      raise EffectiveOrders::AlreadyPurchasedException.new('order already purchased') if self.purchased?
+      raise EffectiveOrders::AlreadyDeclinedException.new('order already declined') if (self.declined? && opts[:validate])
+
+      Order.transaction do
+        self.purchase_state = EffectiveOrders::PURCHASED
+        self.purchased_at ||= Time.zone.now
+        self.payment = payment_details.kind_of?(Hash) ? payment_details : {:details => (payment_details || 'none').to_s}
+
+        order_items.each { |item| item.purchasable.purchased!(self, item) }
+
+        self.save!(:validate => opts[:validate])
+
+        if EffectiveOrders.mailer[:send_order_receipt_to_admin] && opts[:email]
+          if Rails.env.production?
+            (OrdersMailer.order_receipt_to_admin(self).deliver rescue false)
+          else
+            OrdersMailer.order_receipt_to_admin(self).deliver
+          end
+        end
+
+        if EffectiveOrders.mailer[:send_order_receipt_to_buyer] && opts[:email]
+          if Rails.env.production?
+            (OrdersMailer.order_receipt_to_buyer(self).deliver rescue false)
+          else
+            OrdersMailer.order_receipt_to_buyer(self).deliver
+          end
+        end
+
+        if EffectiveOrders.mailer[:send_order_receipt_to_seller] && self.purchased?(:stripe_connect) && opts[:email]
+          self.order_items.group_by(&:seller).each do |seller, order_items|
+            if Rails.env.production?
+              (OrdersMailer.order_receipt_to_seller(self, seller, order_items).deliver rescue false)
+            else
+              OrdersMailer.order_receipt_to_seller(self, seller, order_items).deliver
+            end
+          end
+        end
+
+        return true
+      end
+
+      false
+    end
+
+    def decline!(payment_details = nil)
+      raise EffectiveOrders::AlreadyPurchasedException.new('order already purchased') if self.purchased?
+      raise EffectiveOrders::AlreadyDeclinedException.new('order already declined') if self.declined?
+
+      Order.transaction do
+        self.purchase_state = EffectiveOrders::DECLINED
+        self.payment = payment_details.kind_of?(Hash) ? payment_details : {:details => (payment_details || 'none').to_s}
+
+        order_items.each { |item| item.purchasable.declined!(self, item) }
+
+        self.save!
+      end
+    end
+
+    def purchased?(provider = nil)
+      return false if (purchase_state != EffectiveOrders::PURCHASED)
+      return true if provider == nil
+
+      begin
+        case provider
+        when :stripe_connect
+          payment.keys.first.kind_of?(Numeric) && payment[payment.keys.first].key?('object') && payment[payment.keys.first]['object'] == 'charge'
+        when :stripe
+          payment.key?('object') && payment['object'] == 'charge'
+        when :moneris
+          payment.key?('response_code') && payment.key?('transactionKey')
+        when :paypal
+        else
+          false
+        end
+      rescue => e
+        false
+      end
+    end
+
+    def declined?
+      purchase_state == EffectiveOrders::DECLINED
+    end
+  end
+end

data/app/models/effective/order_item.rb

@@ -0,0 +1,69 @@
+module Effective
+  class OrderItem < ActiveRecord::Base
+    self.table_name = EffectiveOrders.order_items_table_name.to_s
+
+    belongs_to :order
+    belongs_to :purchasable, :polymorphic => true
+    belongs_to :seller, :class_name => 'User'
+
+    structure do
+      title                 :string, :validates => [:presence]
+      quantity              :integer, :validates => [:presence, :numericality]
+      price                 :integer, :default => 0, :validates => [:numericality]
+      tax_exempt            :boolean, :validates => [:inclusion => {:in => [true, false]}]
+      tax_rate              :decimal, :precision => 5, :scale => 3, :default => 0.000, :validates => [:presence]
+
+      timestamps
+    end
+
+    validates_associated :purchasable
+    validates_presence_of :purchasable
+    accepts_nested_attributes_for :purchasable, :allow_destroy => false, :reject_if => :all_blank, :update_only => true
+
+    validates_presence_of :seller_id, :if => Proc.new { |order_item| EffectiveOrders.stripe_connect_enabled }
+
+    delegate :purchased_download_url, :to => :purchasable
+    delegate :purchased?, :declined?, :to => :order
+
+    scope :sold, -> { joins(:order).where(:orders => {:purchase_state => EffectiveOrders::PURCHASED}) }
+    scope :sold_by, lambda { |user| sold().where(:seller_id => user.try(:id)) }
+
+    def subtotal
+      price * quantity
+    end
+
+    def tax  # This is the total tax, for 3 items if quantity is 3
+      tax_exempt ? 0 : (subtotal * tax_rate).ceil
+    end
+
+    def total
+      subtotal + tax
+    end
+
+    def price=(value)
+      if 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
+        ActiveSupport::Deprecation.warn('order_item.price= was passed a non-integer. Expecting an Integer representing the number of cents.  Continuing with (price * 100.0).floor conversion') unless EffectiveOrders.silence_deprecation_warnings
+        super((value.to_f * 100.0).to_i)
+      end
+    end
+
+    # This is going to return an Effective::Customer object that matches the purchasable.user
+    # And is the Customer representing who is selling the product
+    # This is really only used for StripeConnect
+    def seller
+      @seller ||= Effective::Customer.for_user(purchasable.try(:seller))
+    end
+
+    def stripe_connect_application_fee
+      @stripe_connect_application_fee ||= (
+        self.instance_exec(self, &EffectiveOrders.stripe_connect_application_fee_method).to_i.tap do |fee|
+          raise ArgumentError.new("expected EffectiveOrders.stripe_connect_application_fee_method to return a value between 0 and the order_item total (#{self.total}).  Received #{fee}.") if (fee > total || fee < 0)
+        end
+      )
+    end
+  end
+end

data/app/models/effective/stripe_charge.rb

@@ -0,0 +1,35 @@
+# This is an object for the stripe charge form
+module Effective
+  class StripeCharge
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+    include ActiveModel::Validations
+    include ActiveRecord::Reflection
+
+    attr_accessor :effective_order_id, :order, :token # For our form
+
+    validates_presence_of :effective_order_id, :token
+
+    def initialize(params = {})
+      if params.kind_of?(Effective::Order)
+        @order = params
+        @effective_order_id = params.to_param
+      else
+        params.each { |k, v| self.send("#{k}=", v) if self.respond_to?("#{k}=") }
+      end
+    end
+
+    def persisted?
+      false
+    end
+
+    def order_items
+      order.order_items.reject { |order_item| order_item.purchasable.kind_of?(Effective::Subscription) }
+    end
+
+    def subscriptions
+      order.order_items.select { |order_item| order_item.purchasable.kind_of?(Effective::Subscription) }.map(&:purchasable)
+    end
+
+  end
+end

data/app/models/effective/subscription.rb

@@ -0,0 +1,95 @@
+module Effective
+  class Subscription < ActiveRecord::Base
+    include EffectiveStripeHelper
+
+    self.table_name = EffectiveOrders.subscriptions_table_name.to_s
+
+    acts_as_purchasable
+
+    belongs_to :customer
+
+    structure do
+      stripe_plan_id          :string, :validates => [:presence]  # This will be 'Weekly' or something like that
+      stripe_subscription_id  :string
+      stripe_coupon_id        :string
+
+      title                   :string, :validates => [:presence]
+      price                   :integer, :default => 0, :validates => [:numericality => {:greater_than => 0}]
+
+      timestamps
+    end
+
+    delegate :user, :user_id, :to => :customer
+
+    validates_presence_of :customer
+    validates_uniqueness_of :customer_id, :scope => [:stripe_plan_id] # Can only be on each plan once.
+
+    before_validation do
+      self.errors.add(:stripe_plan_id, "is an invalid Plan") if stripe_plan_id.present? && stripe_plan.blank?
+      self.errors.add(:stripe_coupon_id, "is an invalid Coupon") if stripe_coupon_id.present? && stripe_coupon.blank?
+    end
+
+    def tax_exempt
+      true
+    end
+
+    def stripe_plan_id=(plan_id)
+      unless self[:stripe_plan_id] == plan_id
+        self[:stripe_plan_id] = plan_id
+        @stripe_plan = nil   # Remove any memoization
+
+        assign_price_and_title()
+      end
+    end
+
+    def stripe_coupon_id=(coupon_id)
+      unless self[:stripe_coupon_id] == coupon_id
+        self[:stripe_coupon_id] = coupon_id
+        @stripe_coupon = nil   # Remove any memoization
+
+        assign_price_and_title()
+      end
+    end
+
+    def stripe_plan
+      if stripe_plan_id.present?
+        @stripe_plan ||= (Stripe::Plan.retrieve(stripe_plan_id) rescue nil)
+      end
+    end
+
+    def stripe_coupon
+      if stripe_coupon_id.present?
+        @stripe_coupon ||= (Stripe::Coupon.retrieve(stripe_coupon_id) rescue nil)
+      end
+    end
+
+    def stripe_subscription
+      if stripe_subscription_id.present?
+        @stripe_subscription ||= (customer.stripe_customer.subscriptions.retrieve(stripe_subscription_id) rescue nil)
+      end
+    end
+
+    private
+
+    def assign_price_and_title
+      if stripe_plan
+        if stripe_coupon
+          self.price = price_with_coupon(stripe_plan.amount, stripe_coupon)
+          self.title = stripe_plan_description(stripe_plan) + '<br>Coupon Code: ' + stripe_coupon_description(stripe_coupon)
+        else
+          self.title = stripe_plan_description(stripe_plan)
+          self.price = stripe_plan.amount
+        end
+      end
+    end
+
+    def price_with_coupon(amount, coupon)
+      if coupon.percent_off.present?
+        (amount * (coupon.percent_off.to_i / 100.0)).floor
+      else
+        [0, amount - coupon.amount_off].max
+      end
+    end
+
+  end
+end

data/app/models/inputs/price_field.rb

@@ -0,0 +1,63 @@
+module Inputs
+  class PriceField
+    delegate :content_tag, :text_field_tag, :hidden_field_tag, :to => :@template
+
+    def initialize(object, object_name, template, method, opts)
+      @object = object
+      @object_name = object_name
+      @template = template
+      @method = method
+      @opts = opts
+    end
+
+    def to_html
+      content_tag(:div, :class => 'input-group') do
+        content_tag(:span, '$', :class => 'input-group-addon') +
+        text_field_tag(field_name, value, options) +
+        hidden_field_tag(field_name, price, :id => price_field)
+      end
+    end
+
+    private
+
+    # These two are for the text field
+
+    def field_name
+      @object_name + "[#{@method}]"
+    end
+
+    def value
+      val = @object.send(@method) || 0
+      val.kind_of?(Integer) ? ('%.2f' % (val / 100.0)) : ('%.2f' % val)
+    end
+
+    # These two are for the hidden input
+    def price_field
+      "#{field_name.parameterize.gsub('-', '_')}_value_as_integer"
+    end
+
+    def price
+      val = @object.send(@method) || 0
+      val.kind_of?(Integer) ? val : (val * 100.0).to_i
+    end
+
+    def options
+      (@opts || {}).tap do |options|
+        if options[:class].blank?
+          options[:class] = 'numeric'
+        elsif options[:class].kind_of?(Array)
+          options[:class] << :numeric
+        elsif options[:class].kind_of?(String)
+          options[:class] << ' numeric'
+        end
+
+        options[:pattern] = "[0-9]+(\\.[0-9][0-9]){1}"
+        options[:maxlength] = 14
+        options[:title] = 'a price like 19.99, 10000.99 or 0.00'
+        options[:onchange] = "console.log(this.value);"
+        options[:onchange] = "document.querySelectorAll('##{price_field}')[0].setAttribute('value', ((parseFloat(this.value) || 0.00) * 100.0).toFixed(0));"
+      end
+    end
+  end
+end
+

data/app/models/inputs/price_form_input.rb

@@ -0,0 +1,7 @@
+module Inputs
+  module PriceFormInput
+    def price_field(method, opts = {})
+      Inputs::PriceField.new(@object, @object_name, @template, method, opts).to_html
+    end
+  end
+end

data/app/models/inputs/price_formtastic_input.rb

@@ -0,0 +1,9 @@
+if defined?(Formtastic)
+  class PriceFormtasticInput < Formtastic::Inputs::NumberInput
+    def to_html
+      input_wrapping do
+        label_html << Inputs::PriceField.new(@object, @object_name, @template, @method, @options).to_html
+      end
+    end
+  end
+end

data/app/models/inputs/price_input.rb

@@ -0,0 +1,19 @@
+# This allows the app to call f.input :something, :as => :price
+# in either Formtastic or SimpleForm, but not both at the same time
+
+if defined?(SimpleForm)
+  class PriceInput < SimpleForm::Inputs::NumericInput
+    def input(wrapper_options = nil)
+      options = merge_wrapper_options(input_html_options, wrapper_options)
+      Inputs::PriceField.new(object, object_name, template, attribute_name, options).to_html
+    end
+  end
+elsif defined?(Formtastic)
+  class PriceInput < Formtastic::Inputs::NumberInput
+    def to_html
+      input_wrapping do
+        label_html << Inputs::PriceField.new(@object, @object_name, @template, @method, @options).to_html
+      end
+    end
+  end
+end

data/app/models/inputs/price_simple_form_input.rb

@@ -0,0 +1,8 @@
+if defined?(SimpleForm)
+  class PriceSimpleFormInput < SimpleForm::Inputs::NumericInput
+    def input(wrapper_options = nil)
+      options = merge_wrapper_options(input_html_options, wrapper_options)
+      Inputs::PriceField.new(object, object_name, template, attribute_name, options).to_html
+    end
+  end
+end

data/app/models/validators/effective/sold_out_validator.rb

@@ -0,0 +1,7 @@
+module Effective
+  class SoldOutValidator < ActiveModel::Validator
+    def validate(record)
+      record.errors[:base] << "sold out" if record.sold_out?
+    end
+  end
+end

data/app/views/active_admin/effective_orders/orders/_show.html.haml

@@ -0,0 +1,70 @@
+.panel
+  %h3= "Order ##{order.to_param} Details"
+  .panel_contents
+    .attributes_table
+      %table
+        %tbody
+          %tr
+            %th order
+            %td= "##{order.to_param}"
+          %tr
+            %th buyer
+            %td= link_to order.user, admin_user_path(order.user)
+          %tr
+            %th purchase state
+            %td= order.purchase_state
+          - if order.purchased?
+            %tr
+              %th purchased
+              %td= order.purchased_at.strftime("%Y-%m-%d %H:%M")
+          - if order.billing_address.present?
+            %tr
+              %th billing address
+              %td= order.billing_address.to_html
+          - if order.shipping_address.present?
+            %tr
+              %th shipping address
+              %td= order.shipping_address.to_html
+
+.panel
+  %h3 Order Items
+  .panel_contents
+    .attributes_table
+      - has_seller = order.purchased?(:stripe_connect)
+      %table.table
+        %thead
+          %tr
+            %th Items
+            %th Price
+            - if has_seller
+              %th Seller
+        %tbody
+          - order.order_items.each do |item|
+            %tr
+              %td
+                - if item.quantity > 1
+                  = "#{item.quantity}x "
+                = item.title
+              %td= price_to_currency(item.subtotal)
+              - if has_seller
+                %td= link_to item.seller.user, admin_user_path(item.seller.user)
+        %tfoot
+          %tr
+            %th Subtotal
+            %td= price_to_currency(order.subtotal)
+          %tr
+            %th Tax
+            %td= price_to_currency(order.tax)
+          %tr
+            %th Total
+            %td= price_to_currency(order.total)
+
+- if order.payment.present?
+  .panel
+    %h3 Payment
+    .panel_contents
+      .attributes_table
+        = order_payment_to_html(order) rescue order.payment
+
+
+

data/app/views/admin/customers/_actions.html.haml

@@ -0,0 +1,2 @@
+- if customer.stripe_customer_id.present?
+  = link_to 'Manage', "https://manage.stripe.com/customers/#{customer.stripe_customer_id}"

data/app/views/admin/customers/index.html.haml

@@ -0,0 +1,10 @@
+%h2 Customers
+
+- unless @datatable.collection.length > 0
+  %p 
+    There are no customers
+- else
+  = render_datatable @datatable
+
+%hr
+%p= link_to 'Stripe Dashboard: Customers', 'https://manage.stripe.com/customers', :class => 'btn btn-primary'

data/app/views/admin/orders/index.html.haml

@@ -0,0 +1,7 @@
+%h2 Orders
+
+- unless @datatable.collection.length > 0
+  %p 
+    There are no orders
+- else
+  = render_datatable @datatable

data/app/views/admin/orders/show.html.haml

@@ -0,0 +1,11 @@
+= render :partial => 'effective/orders/order', :locals => {:order => @order}
+%hr
+= render :partial => 'effective/orders/order_payment_details', :locals => {:order => @order}
+
+%hr
+= link_to 'Back', effective_orders.admin_orders_path, :class => 'btn btn-primary'
+- if @order.purchased?
+  = '-'
+  = link_to 'Resend Receipt', effective_orders.resend_buyer_receipt_path(@order), 'data-confirm' => 'This action will email the buyer a copy of the original email receipt.  Send receipt now?', :class => 'btn btn-default'
+
+