workarea-sezzle 1.0.0

data/app/controllers/workarea/storefront/checkout/place_order_controller.decorator

@@ -0,0 +1,11 @@
+module Workarea
+  decorate Storefront::Checkout::PlaceOrderController, with: 'sezzle' do
+    def place_order
+      if params[:payment] == 'sezzle' && !current_checkout.payment.sezzle?
+        redirect_to start_sezzle_path and return
+      else
+        super
+      end
+    end
+  end
+end

data/app/controllers/workarea/storefront/sezzle_controller.rb

@@ -0,0 +1,109 @@
+module Workarea
+  class Storefront::SezzleController < Storefront::ApplicationController
+    include Storefront::CurrentCheckout
+
+    before_action :validate_checkout
+
+    def start
+      self.current_order = current_checkout.order
+
+      Pricing.perform(current_order, current_shipping)
+
+      check_inventory || (return)
+
+      # get a sezzle session for the current order
+      order_payload = Sezzle::OrderBuilder.new(current_order).build
+      response = gateway.create_session(order_payload)
+
+      if !response.success?
+        flash[:error] = t('workarea.storefront.sezzle.payment_error')
+        redirect_to(checkout_payment_path) && (return)
+      end
+
+      payment = Workarea::Payment.find(current_order.id)
+
+      payment.clear_credit_card
+
+      tender_attrs = {
+        sezzle_id: response.body['order']['uuid'],
+        sezzle_response: response.body.to_json,
+        intent: Workarea.config.sezzle_payment_action
+      }
+
+      payment.set_sezzle(tender_attrs)
+
+      redirect_url = response.body['order']['checkout_url']
+      redirect_to redirect_url
+    end
+
+    def complete
+      self.current_order = Order.find(params[:order_id]) rescue nil
+      payment = current_checkout.payment
+
+      current_order.user_id = current_user.try(:id)
+      check_inventory || (return)
+
+      shipping = current_shipping
+
+      Pricing.perform(current_order, shipping)
+      payment.adjust_tender_amounts(current_order.total_price)
+
+      # place the order.
+      if current_checkout.place_order
+        completed_place_order
+      else
+        incomplete_place_order
+      end
+    end
+
+    def cancel
+      self.current_order = Order.find(params[:order_id])
+
+      current_order.user_id = current_user.try(:id)
+
+      payment = current_checkout.payment
+      payment.clear_sezzle
+
+      flash[:success] = t('workarea.storefront.sezzle.cancel_message')
+
+      redirect_to checkout_payment_path
+    end
+
+    private
+
+    def gateway
+      Sezzle.gateway
+    end
+
+    def completed_place_order
+      Storefront::OrderMailer.confirmation(current_order.id).deliver_later
+      self.completed_order = current_order
+      clear_current_order
+
+      flash[:success] = t('workarea.storefront.flash_messages.order_placed')
+      redirect_to finished_checkout_destination
+    end
+
+    def incomplete_place_order
+      if current_checkout.shipping.try(:errors).present?
+        flash[:error] = current_checkout.shipping.errors.to_a.to_sentence
+        redirect_to checkout_shipping_path
+      else
+        flash[:error] = t('workarea.storefront.sezzle.payment_error')
+
+        payment = current_checkout.payment
+        payment.clear_sezzle
+
+        redirect_to checkout_payment_path
+      end
+    end
+
+    def finished_checkout_destination
+      if current_admin.present? && current_admin.orders_access?
+        admin.order_path(completed_order)
+      else
+        checkout_confirmation_path
+      end
+    end
+  end
+end

data/app/models/workarea/payment/authorize/sezzle.rb

@@ -0,0 +1,32 @@
+module Workarea
+  class Payment
+    module Authorize
+      class Sezzle
+        include OperationImplementation
+        include CreditCardOperation
+
+        # sezzle authorizes the funds on their platform. No call is made to the
+        # API. Workarea just records the response for posterity.
+        def complete!
+          transaction.response = ActiveMerchant::Billing::Response.new(
+            true,
+            I18n.t(
+              'workarea.sezzle.authorize',
+              amount: transaction.amount
+            ),
+            pre_authorized_response_message
+          )
+        end
+
+        private
+
+        def pre_authorized_response_message
+          {
+            message: I18n.t('workarea.sezzle.pre_authorized_message',
+                            amount: transaction.amount)
+          }
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/payment/capture/sezzle.rb

@@ -0,0 +1,85 @@
+module Workarea
+  class Payment
+    class Capture
+      class Sezzle
+        include OperationImplementation
+        include CreditCardOperation
+
+        def complete!
+          # if the intent of the intial order was CAPTURE then Workarea will just record a message
+          # on the transaction and not reach out to the third party. Tenders with an intent of
+          # capture will already be captured by sezzle during the users checkout process.
+          if tender.intent == 'CAPTURE'
+            transaction.response = ActiveMerchant::Billing::Response.new(
+              true,
+              I18n.t(
+                'workarea.sezzle.capture',
+                amount: transaction.amount
+              ),
+              pre_captured_response_message
+            )
+          else
+            gateway_capture
+          end
+        end
+
+        def cancel!
+          return unless transaction.success?
+
+          payment_id = transaction.response.params['id']
+          response = gateway.void(payment_id)
+
+          transaction.cancellation = ActiveMerchant::Billing::Response.new(
+            true,
+            I18n.t('workarea.sezzle.void'),
+            response.body
+          )
+        end
+
+        private
+
+        def pre_captured_response_message
+          {
+            message: I18n.t('workarea.sezzle.pre_captured_message',
+                            amount: transaction.amount)
+          }
+        end
+
+        def gateway
+          Workarea::Sezzle.gateway
+        end
+
+        def transaction_options
+          {
+            capture_amount: {
+              amount_in_cents: tender.amount.cents,
+              currency: transaction.amount.currency.iso_code
+            },
+            partial_capture: transaction.amount < tender.amount
+          }
+        end
+
+        def gateway_capture
+          response = gateway.capture(tender.sezzle_id, transaction_options)
+
+          if response.success?
+            transaction.response = ActiveMerchant::Billing::Response.new(
+              true,
+              I18n.t(
+                'workarea.sezzle.capture',
+                amount: transaction.amount
+              ),
+              response.body
+            )
+          else
+            transaction.response = ActiveMerchant::Billing::Response.new(
+              false,
+              I18n.t('workarea.sezzle.capture_failure'),
+              response.body
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/payment/purchase/sezzle.rb

@@ -0,0 +1,30 @@
+module Workarea
+  class Payment
+    module Purchase
+      class Sezzle
+        include OperationImplementation
+        include CreditCardOperation
+
+        def complete!
+          transaction.response = ActiveMerchant::Billing::Response.new(
+            true,
+            I18n.t(
+              'workarea.sezzle.purchase',
+              amount: transaction.amount
+            ),
+            pre_purchased_response_message
+          )
+        end
+
+        private
+
+        def pre_purchased_response_message
+          {
+            message: I18n.t('workarea.sezzle.pre_purchased_message',
+                            amount: transaction.amount)
+          }
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/payment/refund/sezzle.rb

@@ -0,0 +1,47 @@
+module Workarea
+  class Payment
+    class Refund
+      class Sezzle
+        include OperationImplementation
+        include CreditCardOperation
+
+        def complete!
+          response = gateway.refund(tender.sezzle_id, transaction_options)
+          if response.success?
+            transaction.response = ActiveMerchant::Billing::Response.new(
+              true,
+              I18n.t(
+                'workarea.sezzle.refund',
+                amount: transaction.amount
+              ),
+              response.body
+            )
+          else
+            transaction.response = ActiveMerchant::Billing::Response.new(
+              false,
+              I18n.t('workarea.sezzle.refund'),
+              response.body
+            )
+          end
+        end
+
+        def cancel!
+          #no-op - nothing to role back on refund.
+        end
+
+        private
+
+        def gateway
+          Workarea::Sezzle.gateway
+        end
+
+        def transaction_options
+          {
+            amount_in_cents: transaction.amount.cents,
+            currency: transaction.amount.currency.iso_code
+          }
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/payment/tender/sezzle.rb

@@ -0,0 +1,15 @@
+module Workarea
+  class Payment
+    class Tender
+      class Sezzle < Tender
+        field :intent, type: String
+        field :sezzle_id, type: String
+        field :sezzle_response, type: String
+
+        def slug
+          :sezzle
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/paymentl.decorator

@@ -0,0 +1,32 @@
+module Workarea
+  decorate Payment, with: :sezzle do
+    decorated do
+      embeds_one :sezzle, class_name: 'Workarea::Payment::Tender::Sezzle'
+    end
+
+    def sezzle?
+      sezzle.present?
+    end
+
+    def set_sezzle(attrs)
+      build_sezzle unless sezzle
+      sezzle.attributes = attrs.slice(
+        :sezzle_id,
+        :sezzle_response,
+        :intent
+      )
+
+      save
+    end
+
+    def clear_sezzle
+      self.sezzle = nil
+      save
+    end
+
+    def set_credit_card(*)
+      self.sezzle = nil
+      super
+    end
+  end
+end

data/app/services/workarea/sezzle/order_builder.rb

@@ -0,0 +1,135 @@
+module Workarea
+  module Sezzle
+    class OrderBuilder
+      module ProductUrl
+        include Workarea::I18n::DefaultUrlOptions
+        include Storefront::Engine.routes.url_helpers
+        extend self
+      end
+      attr_reader :order
+
+      # @param  ::Workarea::Order
+      def initialize(order)
+        @order = Workarea::Storefront::OrderViewModel.new(order)
+      end
+
+      def build
+        {
+          cancel_url: {
+            href: cancel_url,
+            method: 'GET'
+          },
+          complete_url: {
+            href: complete_url,
+            method: 'GET'
+          },
+          customer: {
+            tokenization: true,
+            email: order.email,
+            first_name: payment.address.first_name,
+            last_name: payment.address.last_name,
+            phone: phone_number,
+            dob: nil, # workarea does not collect oob,
+            billing_address: address(payment.address),
+            shipping_address: address(shipping&.address)
+          },
+          order: {
+            intent: Workarea.config.sezzle_payment_action,
+            reference_id: order.id,
+            description: "Sezzle Order #{order.id}",
+            requires_shipping_info: false,
+            items: items,
+            discounts: discounts,
+            shipping_amount: {
+              amount_in_cents: order.shipping_total.cents,
+              currency: currency_code
+            },
+            tax_amount: {
+              amount_in_cents: order.tax_total.cents,
+              currency: currency_code
+            },
+            order_amount: {
+              amount_in_cents: order.order_balance.cents,
+              currency: currency_code
+            }
+          }
+        }
+      end
+
+      private
+
+      def currency_code
+        @currency_code = order.total_price.currency.iso_code
+      end
+
+      def shipping
+        @shipping = Workarea::Shipping.find_by_order(order.id)
+      end
+
+      def payment
+        @payment = Workarea::Payment.find(order.id)
+      end
+
+      def address(address_obj)
+        return {} unless address_obj.present?
+
+        {
+          name: "#{address_obj.first_name} #{address_obj.last_name}",
+          street: address_obj.street,
+          street2: address_obj.street_2,
+          city: address_obj.city,
+          state: address_obj.region,
+          postal_code: address_obj.postal_code,
+          country_code: address_obj.country.alpha2,
+          phone_number: address_obj.phone_number
+        }
+      end
+
+      def items
+        order.items.map do |oi|
+          product = Workarea::Catalog::Product.find_by_sku(oi.sku)
+          {
+            name: product.name,
+            sku: oi.sku,
+            quantity: oi.quantity,
+            price: {
+              amount_in_cents: oi.total_price.cents,
+              currency: currency_code
+            }
+          }
+        end
+      end
+
+      def discounts
+        discounts = order.price_adjustments.select { |p| p.discount? }
+        discounts.map do |d|
+          {
+            name: d.description,
+            amount: {
+              amount_in_cents: d.amount.abs.cents,
+              currency: currency_code
+            }
+          }
+        end
+      end
+
+      def complete_url
+        Storefront::Engine.routes.url_helpers.complete_sezzle_url(
+          host: Workarea.config.host,
+          order_id: order.id
+        )
+      end
+
+      def cancel_url
+        Storefront::Engine.routes.url_helpers.cancel_sezzle_url(
+          host: Workarea.config.host,
+          order_id: order.id
+        )
+      end
+
+      def phone_number
+        payment.address.phone_number || shipping.address.phone_number
+      end
+    end
+  end
+end