effective_orders 4.5.0

data/app/controllers/effective/providers/paypal.rb

@@ -0,0 +1,33 @@
+module Effective
+  module Providers
+    module Paypal
+      extend ActiveSupport::Concern
+
+      included do
+        skip_before_action :verify_authenticity_token, only: [:paypal_postback]
+      end
+
+      # TODO: Make paypal postback work with admin checkout workflow
+
+      def paypal_postback
+        @order ||= Effective::Order.where(id: (params[:invoice].to_i rescue 0)).first
+
+        (EffectiveOrders.authorize!(self, :update, @order) rescue false)
+
+        if @order.present?
+          if @order.purchased?
+            order_purchased(payment: params, provider: 'paypal', card: params[:payment_type])
+          elsif (params[:payment_status] == 'Completed' && params[:custom] == EffectiveOrders.paypal[:secret])
+            order_purchased(payment: params, provider: 'paypal', card: params[:payment_type])
+          else
+            order_declined(payment: params, provider: 'paypal', card: params[:payment_type])
+          end
+        end
+
+        head(:ok)
+      end
+
+
+    end
+  end
+end

data/app/controllers/effective/providers/phone.rb

@@ -0,0 +1,22 @@
+module Effective
+  module Providers
+    module Phone
+      extend ActiveSupport::Concern
+
+      def phone
+        @order ||= Order.find(params[:id])
+
+        EffectiveOrders.authorize!(self, :update, @order)
+
+        flash[:success] = EffectiveOrders.phone[:success]
+
+        order_deferred(provider: 'phone', deferred_url: phone_params[:deferred_url])
+      end
+
+      def phone_params
+        params.require(:phone).permit(:deferred_url)
+      end
+
+    end
+  end
+end

data/app/controllers/effective/providers/pretend.rb

@@ -0,0 +1,26 @@
+module Effective
+  module Providers
+    module Pretend
+      extend ActiveSupport::Concern
+
+      def pretend
+        @order ||= Order.find(params[:id])
+
+        EffectiveOrders.authorize!(self, :update, @order)
+
+        order_purchased(
+          payment: 'for pretend',
+          provider: 'pretend',
+          card: 'none',
+          purchased_url: pretend_params[:purchased_url],
+          declined_url: pretend_params[:declined_url]
+        )
+      end
+
+      def pretend_params
+        params.require(:pretend).permit(:purchased_url, :declined_url)
+      end
+
+    end
+  end
+end

data/app/controllers/effective/providers/refund.rb

@@ -0,0 +1,33 @@
+module Effective
+  module Providers
+    module Refund
+      extend ActiveSupport::Concern
+
+      def refund
+        @order ||= Order.find(params[:id])
+
+        EffectiveOrders.authorize!(self, :update, @order)
+
+        unless @order.refund?
+          flash[:danger] = 'Unable to process refund order with a positive total'
+          redirect_to effective_orders.order_path(@order)
+          return
+        end
+
+        flash[:success] = EffectiveOrders.refund[:success].presence
+
+        order_purchased(
+          payment: 'refund. no payment required.',
+          provider: 'refund',
+          purchased_url: refund_params[:purchased_url],
+          declined_url: refund_params[:declined_url]
+        )
+      end
+
+      def refund_params
+        params.require(:refund).permit(:purchased_url, :declined_url)
+      end
+
+    end
+  end
+end

data/app/controllers/effective/providers/stripe.rb

@@ -0,0 +1,72 @@
+module Effective
+  module Providers
+    module Stripe
+      extend ActiveSupport::Concern
+
+      def stripe
+        @order = Order.find(params[:id])
+        @customer = Effective::Customer.for_user(@order.user)
+
+        EffectiveOrders.authorize!(self, :update, @order)
+
+        payment = validate_stripe_payment(stripe_params[:payment_intent_id])
+
+        if payment.blank? || !payment.kind_of?(Hash)
+          return order_declined(payment: payment, provider: 'stripe', declined_url: stripe_params[:declined_url])
+        end
+
+        # Update the customer payment fields
+        if payment[:payment_method_id].present?
+          @customer.update!(payment.slice(:payment_method_id, :active_card))
+        end
+
+        order_purchased(
+          payment: payment,
+          provider: 'stripe',
+          card: payment[:card],
+          purchased_url: stripe_params[:purchased_url],
+          declined_url: stripe_params[:declined_url]
+        )
+      end
+
+      private
+
+      def stripe_params
+        params.require(:stripe).permit(:payment_intent_id, :purchased_url, :declined_url)
+      end
+
+      def validate_stripe_payment(payment_intent_id)
+        begin
+          intent = ::Stripe::PaymentIntent.retrieve(payment_intent_id)
+          raise('status is not succeeded') unless intent.status == 'succeeded'
+          raise('charges are not present') unless intent.charges.present?
+
+          charge = intent.charges.data.first
+          raise('charge not succeeded') unless charge.status == 'succeeded'
+
+          card = charge.payment_method_details.try(:card) || {}
+          active_card = "**** **** **** #{card['last4']} #{card['brand']} #{card['exp_month']}/#{card['exp_year']}" if card.present?
+
+          {
+            charge_id: charge.id,
+            payment_method_id: charge.payment_method,
+            payment_intent_id: intent.id,
+
+            active_card: active_card,
+            card: card['brand'],
+
+            amount: charge.amount,
+            created: charge.created,
+            currency: charge.currency,
+            customer: charge.customer,
+            status: charge.status
+          }.compact
+
+        rescue => e
+          e.message
+        end
+      end
+
+    end
+  end
+end

data/app/controllers/effective/subscripter_controller.rb

@@ -0,0 +1,18 @@
+module Effective
+  class SubscripterController < ApplicationController
+    layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:subscriptions] : EffectiveOrders.layout)
+
+    include Effective::CrudController
+
+    submit :save, 'Save', redirect: :back, success: -> { 'Successfully updated plan.' }
+
+    def resource
+      @subscripter ||= Effective::Subscripter.new(current_user: current_user)
+    end
+
+    # StrongParameters
+    def subscripter_params
+      params.require(:effective_subscripter).permit!
+    end
+  end
+end

data/app/controllers/effective/webhooks_controller.rb

@@ -0,0 +1,109 @@
+# New workflow is:
+# customer.updated
+# customer.created
+# customer.subscription.created
+# customer.updated
+# customer.source.created
+# charge.succeeded
+# invoice.created
+# invoice.payment_succeeded
+
+module Effective
+  class WebhooksController < ApplicationController
+    protect_from_forgery except: [:stripe]
+    skip_authorization_check if defined?(CanCan)
+
+    after_action :run_subscribable_buyer_callbacks!
+
+    def stripe
+      @event = (Stripe::Webhook.construct_event(request.body.read, request.env['HTTP_STRIPE_SIGNATURE'], EffectiveOrders.subscriptions[:webhook_secret]) rescue nil)
+      (head(:ok) and return) if request.get? && @event.blank?
+      (head(:bad_request) and return) unless @event
+
+      unless EffectiveOrders.subscriptions[:ignore_livemode]
+        (head(:bad_request) and return) if (params[:livemode] == false && Rails.env.production?)
+      end
+
+      Rails.logger.info "[STRIPE] webhook received: #{@event.type} for #{customer || 'no customer'}"
+
+      Effective::Customer.transaction do
+        case @event.type
+        # when 'customer.created'
+        # when 'customer.updated'
+        # when 'customer.source.created'
+        # when 'customer.source.deleted'
+        # when 'customer.subscription.created'
+        # when 'customer.subscription.updated'
+        # when 'invoice.created'
+        # when 'invoice.payment_succeeded'
+        # when 'invoiceitem.created'
+        # when 'invoiceitem.updated'
+        # when 'charge.succeeded'
+        # when 'charge.failed' # Card declined. 4000 0000 0000 0341
+
+        when 'invoice.payment_succeeded'
+          subscriptions.each { |subscription| subscription.update!(status: EffectiveOrders::ACTIVE) }
+          send_email(:subscription_payment_succeeded, customer)
+        when 'invoice.payment_failed'
+          subscriptions.each { |subscription| subscription.update!(status: EffectiveOrders::PAST_DUE) }
+          send_email(:subscription_payment_failed, customer)
+        when 'customer.subscription.deleted'
+          subscriptions.each { |subscription| subscription.destroy! }
+          send_email(:subscription_canceled, customer)
+        when 'customer.subscription.created'
+          send_email(:subscription_created, customer)
+        when 'customer.subscription.updated'
+          send_email(:subscription_updated, customer)
+        else
+          Rails.logger.info "[STRIPE] successful event: #{@event.type}. Nothing to do."
+        end
+      end
+
+      head(:ok)
+    end
+
+    private
+
+    def customer
+      return unless @event.respond_to?(:data)
+
+      @customer ||= (
+        stripe_customer_id = @event.data.object.customer if @event.data.object.respond_to?(:customer)
+        stripe_customer_id = @event.data.object.id if @event.data.object.object == 'customer'
+
+        Effective::Customer.where(stripe_customer_id: stripe_customer_id || 'none').first
+      )
+    end
+
+    def subscriptions
+      customer.subscriptions.select { |subscription| stripe_plan_ids.include?(subscription.stripe_plan_id) }
+    end
+
+    def stripe_plan_ids
+      return unless @event.respond_to?(:data)
+
+      @stripe_plan_ids ||= begin
+        object = @event.data.object
+        lines = object.respond_to?(:lines) ? object.lines : object.items
+        lines.map { |line| line.plan.id }
+      end
+    end
+
+    def send_email(email, *mailer_args)
+      Effective::OrdersMailer.public_send(email, *mailer_args).public_send(EffectiveOrders.mailer[:deliver_method])
+      Effective::OrdersMailer.public_send(:subscription_event_to_admin, email.to_s, *mailer_args).public_send(EffectiveOrders.mailer[:deliver_method])
+    end
+
+    def run_subscribable_buyer_callbacks!
+      return true if (@event.blank? || @customer.blank?)
+
+      name = ('after_' + @event.type.to_s.gsub('.', '_')).to_sym
+      buyer = @customer.user
+
+      buyer.public_send(name, @event) if buyer.respond_to?(name)
+
+      true
+    end
+
+  end
+end

data/app/datatables/admin/effective_customers_datatable.rb

@@ -0,0 +1,22 @@
+class Admin::EffectiveCustomersDatatable < Effective::Datatable
+   datatable do
+
+    col :id, visible: false
+    col :user
+    col 'user.email'
+
+    if EffectiveOrders.stripe?
+      col :stripe_customer_id
+      col :active_card
+    end
+
+    actions_col do |customer|
+      link_to('Manage', "https://dashboard.stripe.com/#{'test/' if Rails.env.development?}customers/#{customer.stripe_customer_id}")
+    end
+
+  end
+
+  collection do
+    Effective::Customer.joins(:user).all
+  end
+end

data/app/datatables/admin/effective_orders_datatable.rb

@@ -0,0 +1,100 @@
+class Admin::EffectiveOrdersDatatable < Effective::Datatable
+  bulk_actions do
+    bulk_action(
+    'Send payment request email to selected orders',
+      effective_orders.bulk_send_payment_request_admin_orders_path,
+      data: { confirm: 'Send payment request emails?' }
+    )
+
+    bulk_action(
+    'Send receipt email to selected purchased orders',
+      effective_orders.bulk_send_buyer_receipt_orders_path,
+      data: { confirm: 'Send receipt emails?' }
+    )
+  end
+
+  filters do
+    scope :purchased, default: true
+    scope :deferred
+    scope :refunds
+    scope :not_purchased
+    scope :all
+  end
+
+  datatable do
+    order :id, :desc
+
+    bulk_actions_col
+
+    col :created_at, visible: false
+    col :updated_at, visible: false
+
+    col :id, label: 'Number' do |order|
+      '#' + order.to_param
+    end
+
+    col :purchased_at do |order|
+      order.purchased_at&.strftime('%F %H:%M') || 'not purchased'
+    end
+
+    if attributes[:user_id].blank?
+      col :user
+      col :billing_name, visible: false
+      col :email, visible: false
+    end
+
+    col :cc, visible: false
+
+    if EffectiveOrders.billing_address
+      col :billing_address, visible: false
+    end
+
+    if EffectiveOrders.shipping_address
+      col :shipping_address, visible: false
+    end
+
+    col :order_items, search: { as: :string }
+
+    col :subtotal, as: :price, visible: false
+    col :tax, as: :price, visible: false
+
+    col :tax_rate, visible: false do |order|
+      tax_rate_to_percentage(order.tax_rate)
+    end
+
+    col :total, as: :price
+
+    col :payment_provider, label: 'Provider', visible: false, search: { collection: EffectiveOrders.payment_providers }
+    col :payment_card, label: 'Card', visible: false
+
+    if EffectiveOrders.collect_note
+      col :note, visible: false
+    end
+
+    col :note_to_buyer, visible: false
+    col :note_internal, visible: false
+
+    actions_col partial: 'admin/orders/datatable_actions', partial_as: :order
+
+    aggregate :total
+  end
+
+  collection do
+    scope = Effective::Order.all.includes(:addresses, :order_items, :user)
+
+    if EffectiveOrders.orders_collection_scope.respond_to?(:call)
+      scope = EffectiveOrders.orders_collection_scope.call(scope)
+    end
+
+    if attributes[:user_id].present?
+      scope = scope.where(user: user)
+    end
+
+    scope
+  end
+
+  def user
+    @user ||= User.find(attributes[:user_id])
+  end
+
+end

data/app/datatables/effective_orders_datatable.rb

@@ -0,0 +1,79 @@
+# This is a user specific EffectiveOrdersDatatable
+
+class EffectiveOrdersDatatable < Effective::Datatable
+  filters do
+    unless attributes[:not_purchased]
+      scope :purchased, default: true
+      scope :deferred
+      scope :refunds
+      scope :not_purchased
+      scope :all
+    end
+  end
+
+  datatable do
+    order :id, :desc
+
+    col :created_at, visible: false
+    col :updated_at, visible: false
+
+    col :id, label: 'Number' do |order|
+      '#' + order.to_param
+    end
+
+    unless attributes[:not_purchased]
+      col :purchased_at do |order|
+        order.purchased_at&.strftime('%F %H:%M') || 'not purchased'
+      end
+    end
+
+    if EffectiveOrders.billing_address
+      col :billing_address, visible: false
+    end
+
+    if EffectiveOrders.shipping_address
+      col :shipping_address, visible: false
+    end
+
+    col :order_items, search: { as: :string }
+
+    col :subtotal, as: :price, visible: false
+    col :tax, as: :price, visible: false
+
+    col :tax_rate, visible: false do |order|
+      tax_rate_to_percentage(order.tax_rate)
+    end
+
+    col :total, as: :price
+
+    col :payment_provider, label: 'Provider', visible: false, search: { collection: EffectiveOrders.payment_providers }
+    col :payment_card, label: 'Card', visible: false
+
+    if EffectiveOrders.collect_note
+      col :note
+    end
+
+    col :note_to_buyer
+
+    actions_col partial: 'effective/orders/datatable_actions', partial_as: :order
+  end
+
+  collection do
+    scope = Effective::Order.all.where(user: user).includes(:addresses, :order_items, :user)
+
+    if EffectiveOrders.orders_collection_scope.respond_to?(:call)
+      scope = EffectiveOrders.orders_collection_scope.call(scope)
+    end
+
+    if attributes[:not_purchased]
+      scope = scope.not_purchased
+    end
+
+    scope
+  end
+
+  def user
+    @user ||= User.find(attributes[:user_id])
+  end
+
+end