effective_orders 2.2.4 → 3.0.0

data/app/assets/javascripts/effective_orders/providers/stripe_subscriptions.js.coffee

@@ -1,28 +0,0 @@
-stripeCheckoutHandler = (key, form) ->
-  StripeCheckout.configure
-    key: key
-    token: (token, args) ->
-      if token.error
-        form.find("input[type='submit']").removeAttr('disabled')
-        alert("An error ocurred when contacting Stripe.  Your card has not been charged.  Please refresh the page and try again. #{token.error.message}")
-      else
-        form.find("input[type='submit']").prop('disabled', true)
-        form.find('input#effective_providers_stripe_subscription_token').val('' + token['id'])
-        form.submit()
-
-$(document).on 'click', "#effective-orders-new-subscription-form form input[type='submit']", (event) ->
-  event.preventDefault()
-
-  obj = $('#effective-orders-new-subscription-form')
-  form = obj.find('form').first()
-  plan = form.find('option:selected')
-
-  if plan.length > 0
-    form.find("input[type='submit']").prop('disabled', true)
-
-    stripeCheckoutHandler(obj.data('stripe-publishable-key'), form).open
-      name: obj.data('site-title')
-      email: obj.data('user-email')
-      description: plan.text()
-      panelLabel: 'Start Subscription'
-      closed: -> form.find("input[type='submit']").removeAttr('disabled')

data/app/controllers/concerns/acts_as_active_admin_controller.rb

@@ -1,69 +0,0 @@
-module ActsAsActiveAdminController
-  extend ActiveSupport::Concern
-
-  module ActionController
-    def acts_as_active_admin_controller(element_lookup_key)
-      @active_admin_resource_element_lookup_key = element_lookup_key
-      include ::ActsAsActiveAdminController
-    end
-  end
-
-  included do
-    include ActiveAdmin::BaseController::Menu
-    include ActiveAdmin::BaseController::Authorization
-
-    helper ActiveAdmin::ViewHelpers
-    helper_method :active_admin_config, :active_admin_namespace, :current_active_admin_user, :current_active_admin_user?, :env
-
-    resource_key = @active_admin_resource_element_lookup_key.to_s
-    self.send(:define_method, :active_admin_resource_element_key) { resource_key }
-
-    resource_ivar = '@' + resource_key.singularize
-    self.send(:define_method, :resource) { instance_variable_get(resource_ivar) }
-
-    resource_path = "effective_orders.#{resource_key.singularize}_path"
-
-    if resource_path == 'effective_orders.cart_path'
-      self.send(:define_method, :resource_path) { |resource| effective_orders.cart_path }
-    else
-      self.send(:define_method, :resource_path) { |resource| public_send(resource_path, resource) }
-      self.send(:define_method, :edit_resource_path) { |resource| effective_orders.edit_order_path(resource) }
-    end
-
-    helper_method :resource, :resource_path, :edit_resource_path
-  end
-
-  module ClassMethods
-  end
-
-  def active_admin_namespace
-    ActiveAdmin.application.namespaces[EffectiveOrders.active_admin_namespace || :root]
-  end
-
-  def active_admin_config
-    active_admin_namespace.resources[active_admin_resource_key]
-  end
-
-  def active_admin_resource_key
-    @active_admin_resource_key ||= begin
-      namespace = ActiveAdmin.application.namespaces[EffectiveOrders.active_admin_namespace || :root]
-      namespace.resources.keys.find { |resource| resource.element == active_admin_resource_element_key }
-    end
-  end
-
-  # Calls the authentication method as defined in ActiveAdmin.authentication_method
-  def authenticate_active_admin_user
-    send(active_admin_namespace.authentication_method) if active_admin_namespace.authentication_method
-  end
-
-  def current_active_admin_user
-    send(active_admin_namespace.current_user_method) if active_admin_namespace.current_user_method
-  end
-
-  def current_active_admin_user?
-    !!current_active_admin_user
-  end
-
-
-end
-

data/app/controllers/effective/subscriptions_controller.rb

@@ -1,126 +0,0 @@
-module Effective
-  class SubscriptionsController < ApplicationController
-    include EffectiveCartsHelper
-    include EffectiveStripeHelper
-
-    layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:subscriptions] : EffectiveOrders.layout)
-
-    respond_to?(:before_action) ? before_action(:authenticate_user!) : before_filter(:authenticate_user!) # Devise
-    respond_to?(:before_action) ? before_action(:assign_customer) : before_filter(:assign_customer)
-
-    # This is a 'My Subscriptions' page
-    def index
-      @page_title ||= 'My Subscriptions'
-
-      @subscriptions = @customer.subscriptions.purchased
-      @active_stripe_subscription = @subscriptions.map(&:stripe_subscription).find do |subscription|
-        subscription.present? && subscription.status == 'active' && subscription.current_period_end > Time.zone.now.to_i
-      end
-
-      EffectiveOrders.authorized?(self, :index, Effective::Subscription)
-    end
-
-    def new
-      @page_title ||= 'New Subscription'
-
-      @subscription = @customer.subscriptions.new()
-
-      purchased_plans = @customer.subscriptions.purchased.map(&:stripe_plan_id)
-      @plans = Stripe::Plan.all.reject { |stripe_plan| purchased_plans.include?(stripe_plan.id) }
-
-      EffectiveOrders.authorized?(self, :new, @subscription)
-    end
-
-    def create
-      @page_title ||= 'New Subscription'
-
-      # Don't let the user create another Subscription object if it's already created
-      @subscription = @customer.subscriptions.where(:stripe_plan_id => subscription_params[:stripe_plan_id]).first_or_initialize
-
-      EffectiveOrders.authorized?(self, :create, @subscription)
-
-      if @subscription.update_attributes(subscription_params) && (current_cart.find(@subscription).present? || current_cart.add(@subscription))
-        flash[:success] = "Successfully added subscription to cart."
-        redirect_to effective_orders.new_order_path
-      else
-        purchased_plans = @customer.subscriptions.purchased.map(&:stripe_plan_id)
-        @plans = Stripe::Plan.all.reject { |stripe_plan| purchased_plans.include?(stripe_plan.id) }
-
-        flash[:danger] ||= 'Unable to add subscription to cart.  Please try again.'
-        render :action => :new
-      end
-    end
-
-    def show
-      @plan = Stripe::Plan.retrieve(params[:id])
-
-      unless @plan.present?
-        flash[:danger] = "Unrecognized Stripe Plan: #{params[:id]}"
-        raise ActiveRecord::RecordNotFound
-      end
-
-      @subscription = @customer.subscriptions.find { |subscription| subscription.stripe_plan_id == params[:id] }
-
-      unless @subscription.present?
-        flash[:danger] = "Unable to find Customer Subscription for plan: #{params[:id]}"
-        raise ActiveRecord::RecordNotFound
-      end
-
-      @stripe_subscription = @subscription.try(:stripe_subscription)
-
-      unless @stripe_subscription.present?
-        flash[:danger] = "Unable to find Stripe Subscription for plan: #{params[:id]}"
-        raise ActiveRecord::RecordNotFound
-      end
-
-      EffectiveOrders.authorized?(self, :show, @subscription)
-
-      @invoices = @customer.stripe_customer.invoices.all.select do |invoice|
-        invoice.lines.any? { |line| line.id == @stripe_subscription.id }
-      end
-
-      @page_title ||= "#{@plan.name}"
-    end
-
-    def destroy
-      @plan = Stripe::Plan.retrieve(params[:id])
-      raise ActiveRecord::RecordNotFound unless @plan.present?
-
-      @subscription = @customer.subscriptions.find { |subscription| subscription.stripe_plan_id == params[:id] }
-      @stripe_subscription = @subscription.try(:stripe_subscription)
-      raise ActiveRecord::RecordNotFound unless @subscription.present?
-
-      EffectiveOrders.authorized?(self, :destroy, @subscription)
-
-      if @subscription.present?
-        begin
-          @stripe_subscription.delete if @stripe_subscription
-          @subscription.destroy
-          flash[:success] = "Successfully unsubscribed from #{params[:id]}"
-        rescue => e
-          flash[:danger] = "Unable to unsubscribe.  Message: \"#{e.message}\"."
-        end
-      else
-        flash[:danger] = "Unable to find stripe subscription for #{params[:id]}" unless @subscription.present?
-      end
-
-      redirect_to effective_orders.subscriptions_path
-    end
-
-    private
-
-    def assign_customer
-      @customer ||= Customer.for_user(current_user)
-    end
-
-    # StrongParameters
-    def subscription_params
-      begin
-        params.require(:effective_subscription).permit(:stripe_plan_id, :stripe_coupon_id)
-      rescue => e
-        params[:effective_subscription]
-      end
-    end
-
-  end
-end

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

@@ -1,40 +0,0 @@
-if Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
-  module Effective
-    module Datatables
-      class Customers < Effective::Datatable
-        datatable do
-          default_order :email, :asc
-
-          table_column :id, visible: false
-          table_column(:email, column: 'users.email') { |user| mail_to user.email, user.email }
-
-          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'
-
-          actions_column partial: 'admin/customers/actions'
-        end
-
-        def collection
-          Effective::Customer.customers.uniq
-            .joins(:user, :subscriptions)
-            .select('customers.*, 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, subscriptions.stripe_plan_id, users.email')
-        end
-
-        def search_column(collection, table_column, search_term)
-          return collection.where('subscriptions.stripe_plan_id ILIKE ?', "%#{search_term}%") if table_column[:name] == 'subscription_types'
-          super
-        end
-      end
-    end
-  end
-end

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

@@ -1,101 +0,0 @@
-if Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
-  module Effective
-    module Datatables
-      class OrderItems < Effective::Datatable
-        datatable do
-          default_order :purchased_at, :desc
-
-          table_column(:purchased_at, type: :datetime, column: 'orders.purchased_at') do |order_item|
-            Time.at(order_item[:purchased_at]).in_time_zone if order_item[:purchased_at].present?
-          end
-
-          table_column :id, visible: false
-
-          if EffectiveOrders.obfuscate_order_ids
-            table_column(:order, type: :obfuscated_id, sortable: false) do |order_item|
-              obfuscated_id = Effective::Order.obfuscate(order_item[:order_id])
-              link_to(obfuscated_id, (datatables_admin_path? ? effective_orders.admin_order_path(obfuscated_id) : effective_orders.order_path(obfuscated_id)))
-            end
-          else
-            table_column(:order, sortable: false) do |order_item|
-              link_to(order_item.to_param, (datatables_admin_path? ? effective_orders.admin_order_path(order_item.to_param) : effective_orders.order_path(order_item.to_param)))
-            end
-          end
-
-          table_column :email, column: 'users.email', label: 'Buyer Email', if: proc { attributes[:user_id].blank? } do |order_item|
-            link_to order_item[:email], (edit_admin_user_path(order_item[:user_id]) rescue admin_user_path(order_item[:user_id]) rescue '#')
-          end
-
-          if EffectiveOrders.require_billing_address
-            table_column :buyer_name, sortable: false, label: 'Buyer Name', if: proc { attributes[:user_id].blank? } do |order_item|
-              (order_item[:buyer_name] || '').split('!!SEP!!').find(&:present?)
-            end
-          end
-
-          table_column :purchase_state, column: 'orders.purchase_state', filter: { type: :select, values: [%w(abandoned abandoned), [EffectiveOrders::PURCHASED, EffectiveOrders::PURCHASED], [EffectiveOrders::DECLINED, EffectiveOrders::DECLINED]], selected: EffectiveOrders::PURCHASED } do |order_item|
-            order_item[:purchase_state] || 'abandoned'
-          end
-
-          table_column :title do |order_item|
-            order_item.quantity == 1 ? order_item.title : "#{order_item.title} (#{order_item.quantity} purchased)"
-          end
-
-          table_column(:subtotal) { |order_item| price_to_currency(order_item[:subtotal].to_i) }
-          table_column(:tax) { |order_item| price_to_currency(order_item[:tax].to_i) }
-          table_column(:total) { |order_item| price_to_currency(order_item[:total].to_i) }
-
-          table_column :created_at, visible: false
-          table_column :updated_at, visible: false
-        end
-
-        def collection
-          collection = Effective::OrderItem.unscoped
-            .joins(order: :user)
-            .select('order_items.*, orders.*, users.email AS email')
-            .select("#{query_subtotal} AS subtotal, #{query_tax} AS tax, #{query_total} AS total")
-            .group('order_items.id, orders.id, users.email')
-
-          if EffectiveOrders.require_billing_address && defined?(EffectiveAddresses)
-            addresses_tbl = EffectiveAddresses.addresses_table_name
-
-            collection = collection
-              .joins("LEFT JOIN (SELECT addressable_id, string_agg(#{addresses_tbl}.full_name, '!!SEP!!') AS buyer_name FROM #{addresses_tbl} WHERE #{addresses_tbl}.category = 'billing' AND #{addresses_tbl}.addressable_type = 'Effective::Order' GROUP BY #{addresses_tbl}.addressable_id) #{addresses_tbl} ON orders.id = #{addresses_tbl}.addressable_id")
-              .group("#{addresses_tbl}.buyer_name")
-              .select("#{addresses_tbl}.buyer_name AS buyer_name")
-          end
-
-          attributes[:user_id].present? ? collection.where("#{EffectiveOrders.orders_table_name.to_s}.user_id = ?", attributes[:user_id]) : collection
-        end
-
-        def query_subtotal
-          'SUM(price * quantity)'
-        end
-
-        def query_total
-          'SUM((price * quantity) + (CASE tax_exempt WHEN true THEN 0 ELSE ((price * quantity) * tax_rate) END))'
-        end
-
-        def query_tax
-          '(CASE tax_exempt WHEN true THEN 0 ELSE ((price * quantity) * tax_rate) END)'
-        end
-
-        def search_column(collection, table_column, search_term)
-          if table_column[:name] == 'order'
-            collection.where("#{EffectiveOrders.order_items_table_name.to_s}.order_id = ?", Effective::Order.deobfuscate(search_term))
-          elsif table_column[:name] == 'purchase_state' && search_term == 'abandoned'
-            collection.where("#{EffectiveOrders.orders_table_name.to_s}.purchase_state IS NULL")
-          elsif table_column[:name] == 'subtotal'
-            collection.having("#{query_subtotal} = ?", (search_term.gsub(/[^0-9.]/, '').to_f * 100.0).to_i)
-          elsif table_column[:name] == 'tax'
-            collection.having("#{query_tax} = ?", (search_term.gsub(/[^0-9.]/, '').to_f * 100.0).to_i)
-          elsif table_column[:name] == 'total'
-            collection.having("#{query_total} = ?", (search_term.gsub(/[^0-9.]/, '').to_f * 100.0).to_i)
-          else
-            super
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-module Effective
-  module Datatables
-    class Orders < Effective::Datatable
-      datatable do
-        default_order :created_at, :desc
-
-        table_column :purchased_at
-
-        table_column :id, label: 'ID' do |order|
-          link_to order.to_param, effective_orders.admin_order_path(order)
-        end
-
-        # Don't display email or buyer_name column if this is for a specific user
-        if attributes[:user_id].blank?
-          table_column :email, column: 'users.email', label: 'Buyer Email' do |order|
-            link_to order.user.email, (edit_admin_user_path(order.user) rescue admin_user_path(order.user) rescue '#')
-          end
-
-          if EffectiveOrders.use_address_full_name
-            table_column :buyer_name, column: 'addresses.full_name' do |order|
-              order.billing_address.try(:full_name)
-            end
-
-          elsif # Not using address full name
-            table_column :buyer_name, column: 'users.*' do |order|
-              order.user.to_s
-            end
-          end
-        end
-
-        if EffectiveOrders.require_billing_address
-          table_column :billing_address
-        end
-
-        if EffectiveOrders.require_shipping_address
-          table_column :shipping_address
-        end
-
-        table_column :purchase_state, label: 'State', filter: { values: purchase_state_filter_values } do |order|
-          order.purchase_state || 'abandoned'
-        end
-
-        table_column :order_items, column: 'order_items.title', filter: :string
-
-        table_column :subtotal, as: :price
-        table_column :tax, as: :price
-
-        table_column :tax_rate, visible: false do |order|
-          tax_rate_to_percentage(order.tax_rate)
-        end
-
-        table_column :total, as: :price
-
-        table_column :payment_provider, label: 'Provider', visible: false, filter: { values: ['nil'] + (EffectiveOrders.payment_providers + EffectiveOrders.other_payment_providers).sort }
-        table_column :payment_card, label: 'Card'
-
-        table_column :note, visible: false
-        table_column :note_to_buyer, visible: false
-        table_column :note_internal, visible: false
-
-        table_column :created_at, visible: false
-        table_column :updated_at, visible: false
-
-        actions_column partial: 'admin/orders/actions'
-      end
-
-      def collection
-        collection = Effective::Order.unscoped
-          .joins(:user)
-          .includes(:addresses)
-          .includes(:user)
-          .includes(:order_items)
-
-        if EffectiveOrders.orders_collection_scope.respond_to?(:call)
-          collection = EffectiveOrders.orders_collection_scope.call(collection)
-        end
-
-        attributes[:user_id].present? ? collection.where(user_id: attributes[:user_id]) : collection
-      end
-
-      def purchase_state_filter_values
-        [
-          %w(abandoned nil),
-          [EffectiveOrders::PURCHASED, EffectiveOrders::PURCHASED],
-          [EffectiveOrders::DECLINED, EffectiveOrders::DECLINED],
-          [EffectiveOrders::PENDING, EffectiveOrders::PENDING]
-        ]
-      end
-    end
-  end
-end