workarea-afterpay 2.0.2

data/app/assets/stylesheets/workarea/storefront/components/_afterpay_dialog.scss

@@ -0,0 +1,158 @@
+/*------------------------------------*\
+    #AFTERPAY-DIALOG
+\*------------------------------------*/
+
+$afterpay-navy: #074578 !default;
+$afterpay-blue: #16a0d5 !default;
+$afterpay-aqua: #05cdd5 !default;
+$afterpay-gray: #2d3134 !default;
+$afterpay-magenta: #ec3b91 !default;
+$afterpay-off-gray: #606a72 !default;
+
+$afterpay-dialog-max-width: 700px !default;
+$afterpay-dialog-spacing: $spacing-unit * 3 !default;
+$afterpay-dialog-background-color: $white !default;
+
+@font-face {
+  font-family: 'Raleway';
+  font-style: normal;
+  font-weight: 400;
+    src: font-url('workarea/storefront/raleway/raleway_regular.woff2') format('woff2'),
+         font-url('workarea/storefront/raleway/raleway_regular.woff') format('woff');
+}
+
+@font-face {
+  font-family: 'Raleway';
+  font-style: normal;
+  font-weight: 800;
+    src: font-url('workarea/storefront/raleway/raleway_800.woff2') format('woff2'),
+         font-url('workarea/storefront/raleway/raleway_800.woff') format('woff');
+}
+
+.afterpay-dialog {
+    max-width: $afterpay-dialog-max-width;
+    color: $afterpay-off-gray;
+    font-family: 'Raleway', 'Lucida Grande', Helvetica, sans-serif;
+    background-color: $afterpay-dialog-background-color;
+
+    .style-guide__example-block & {
+        margin: 0 auto;
+    }
+}
+
+.afterpay-dialog--aus {}
+
+    .afterpay-dialog__header {
+        position: relative;
+        padding: $afterpay-dialog-spacing $afterpay-dialog-spacing 0;
+        background-color: #fafbfc;
+        text-align: center;
+
+        .afterpay-dialog--aus & {
+            text-align: left
+        }
+    }
+
+        .afterpay-dialog__logo {
+            padding-bottom: $afterpay-dialog-spacing;
+        }
+
+        .afterpay-dialog__subheading {
+            @extend %inline-list;
+        }
+
+        .afterpay-dialog__subheading-part {
+            line-height: 1.2;
+
+            .afterpay-dialog--aus &:last-of-type {
+                display: block;
+            }
+        }
+
+        .afterpay-dialog__description {
+            padding-bottom: $afterpay-dialog-spacing;
+
+            @include respond-to($medium-breakpoint) {
+                padding-bottom: $afterpay-dialog-spacing * 2;
+            }
+
+            .afterpay-dialog--aus & {
+                width: 75%;
+            }
+        }
+
+        .afterpay-dialog__header-image {
+            width: 100%;
+
+        }
+
+        .afterpay-dialog__heading {
+            color: $afterpay-blue;
+            font-weight: bold;
+            line-height: 1;
+
+            .afterpay-dialog__header & {
+
+            }
+
+            .afterpay-dialog__step & {
+
+                .afterpay-dialog--aus & {
+                    color: $afterpay-gray;
+                }
+            }
+
+            .afterpay-dialog__footer & {
+                color: $afterpay-gray;
+            }
+        }
+
+    .afterpay-dialog__steps {
+        margin: $afterpay-dialog-spacing 0;
+        padding: 0 $afterpay-dialog-spacing;
+    }
+
+        .afterpay-dialog__step {
+            padding: $afterpay-dialog-spacing / 2;
+
+            .afterpay-dialog--aus & {
+                text-align: center;
+            }
+        }
+
+            .afterpay-dialog__step-icon {
+                display: block;
+                height: 100px;
+                margin: 0 auto $afterpay-dialog-spacing;
+
+                .afterpay-dialog--aus & {
+                    height: 74px;
+                }
+            }
+
+            .afterpay-dialog__step-body {
+            }
+
+    .afterpay-dialog__footer {
+        padding: 0 $afterpay-dialog-spacing $afterpay-dialog-spacing;
+    }
+
+        .afterpay-dialog__requirements {
+            padding: 0;
+
+            .afterpay-dialog--aus & {
+                margin: 0;
+            }
+        }
+
+            .afterpay-dialog__requirement {
+                .afterpay-dialog--aus & {
+                    display: inline-block;
+                }
+            }
+
+        .afterpay-dialog__terms {}
+
+        .afterpay-dialog__copyright {
+            text-align: center;
+        }

data/app/controllers/workarea/admin/afterpay/configurations_controller.rb

@@ -0,0 +1,33 @@
+module Workarea
+  module Admin
+    module Afterpay
+      class ConfigurationsController < Admin::ApplicationController
+        required_permissions :settings
+
+        def edit
+          @configuration = configuration
+        end
+
+        def update
+          if configuration.update_attributes(configuration_params)
+            redirect_to admin.edit_afterpay_configuration_path, flash: { success: t('workarea.admin.afterpay_configuration.edit.flash_messages.updated') }
+          else
+            flash[:error] = t('workarea.admin.afterpay_configuration.edit.flash_messages.save_error')
+            @configuration = configuration
+            render :edit, status: :unprocessable_entity
+          end
+        end
+
+        private
+          def configuration
+            model = Workarea::Afterpay::Configuration.current
+            Workarea::Admin::AfterpayConfigurationViewModel.new(model)
+          end
+
+          def configuration_params
+            params.permit(:enabled, :display_on_cart, :display_on_pdp)
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+module Workarea
+  class Storefront::AfterpayController < 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 token for the current order
+      order_payload = Afterpay::OrderBuilder.new(current_order).build
+      response = gateway.create_order(order_payload)
+
+      if !response.success?
+        flash[:error] = t('workarea.storefront.afterpay.payment_error')
+        redirect_to(checkout_payment_path) && (return)
+      end
+
+      token = response.body["token"]
+
+      payment = Workarea::Payment.find(current_order.id)
+
+      payment.clear_credit_card
+
+      payment.set_afterpay(token: token)
+
+      # set the token on the order so we can more easily look up the order
+      # when returning from afterpay
+      current_order.update_attributes!(afterpay_token: token)
+
+      redirect_to checkout_payment_path
+    end
+
+    def complete
+      self.current_order = Order.where(afterpay_token: params[:orderToken]).first
+      payment = current_checkout.payment
+
+      if params[:status] != "SUCCESS"
+        flash[:error] = t('workarea.storefront.afterpay.payment_error')
+        payment.clear_afterpay
+        redirect_to(checkout_payment_path) && (return)
+      end
+
+      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)
+
+      ap_order_details = gateway.get_order(params[:orderToken])
+      tender = payment.afterpay
+
+      unless (ap_order_details.body["totalAmount"]["amount"].to_m == tender.amount.to_m && current_checkout.complete?)
+        flash[:error] = t('workarea.storefront.afterpay.payment_error')
+        payment.clear_afterpay
+        redirect_to(checkout_payment_path) && (return)
+      end
+
+      payment.afterpay.update_attributes!(ready_to_capture: true)
+
+      # place the order.
+      if current_checkout.place_order
+        completed_place_order
+      else
+        incomplete_place_order
+      end
+    end
+
+    def cancel
+      self.current_order = Order.where(afterpay_token: params[:orderToken]).first
+
+      current_order.user_id = current_user.try(:id)
+
+      payment = current_checkout.payment
+      payment.clear_afterpay
+
+      flash[:success] = t('workarea.storefront.afterpay.cancel_message')
+
+      redirect_to checkout_payment_path
+    end
+
+    private
+
+      def gateway
+        Afterpay.gateway(self.current_order.afterpay_location)
+      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.afterpay.payment_error')
+
+          payment = current_checkout.payment
+          payment.clear_afterpay
+
+          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/controllers/workarea/storefront/afterpay_dialog_controller.rb

@@ -0,0 +1,7 @@
+module Workarea
+  class Storefront::AfterpayDialogController < Storefront::ApplicationController
+    def show
+      render 'show_aus' if params[:location] == 'au'
+    end
+  end
+end

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

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

data/app/helpers/workarea/storefront/afterpay_helper.rb

@@ -0,0 +1,16 @@
+module Workarea
+  module Storefront
+    module AfterpayHelper
+      # get the relevant learn more link from
+      # a price.
+      #
+      # @return String
+      def learn_more_link(price)
+        currency = price.currency.iso_code.to_sym
+        location = Workarea::Afterpay.config[:currency_country_map][currency].to_sym.downcase
+        return unless location.present?
+        afterpay_dialog_path(location: location)
+      end
+    end
+  end
+end

data/app/models/workarea/afterpay/configuration.rb

@@ -0,0 +1,16 @@
+module Workarea
+  module Afterpay
+    class Configuration
+      include ApplicationDocument
+
+      field :enabled, type: Boolean, default: true
+
+      field :display_on_cart, type: Boolean, default: true
+      field :display_on_pdp, type: Boolean, default: true
+
+      def self.current
+        Workarea::Afterpay::Configuration.first || Workarea::Afterpay::Configuration.new
+      end
+    end
+  end
+end

data/app/models/workarea/order.decorator

@@ -0,0 +1,17 @@
+module Workarea
+  decorate Order, with: :afterpay do
+    decorated do
+      field :afterpay_token, type: String
+
+      index({ afterpay_token: 1}, { background: true })
+    end
+
+    def afterpay_location
+      currency = total_price.currency.iso_code
+      location = Afterpay.config[:currency_country_map][currency.to_sym]
+      return unless location.present?
+
+      location.to_sym.downcase
+    end
+  end
+end

data/app/models/workarea/payment/afterpay_payment_gateway.rb

@@ -0,0 +1,16 @@
+module Workarea
+  class Payment
+    module AfterpayPaymentGateway
+      # Examines the tenders currency and selects the
+      # correct credentials to use in the gateway
+      #
+      # @return Workarea::Afterpay::Gateway
+      def gateway
+        currency = tender.amount.currency.iso_code
+        location = Afterpay.config[:currency_country_map][currency.to_sym]
+
+        Afterpay.gateway(location.to_sym.downcase)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Workarea
+  class Payment
+    module Authorize
+      Afterpay = Capture::Afterpay
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Workarea
+  class Payment
+    class Capture
+      class Afterpay
+        include OperationImplementation
+        include CreditCardOperation
+        include AfterpayPaymentGateway
+
+        def complete!
+          response = gateway.capture(tender.token, tender.payment.id)
+          if response.success?
+            transaction.response = ActiveMerchant::Billing::Response.new(
+              true,
+              I18n.t(
+                'workarea.afterpay.capture',
+                amount: transaction.amount
+              ),
+              response.body
+            )
+          else
+             transaction.response = ActiveMerchant::Billing::Response.new(
+               false,
+              I18n.t('workarea.afterpay.capture_failure'),
+              response.body
+            )
+          end
+        end
+
+        def cancel!
+          # No op - no cancel functionality available.
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Workarea
+  class Payment
+    module Purchase
+      Afterpay = Capture::Afterpay
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Workarea
+  class Payment
+    class Refund
+      class Afterpay
+        include OperationImplementation
+        include CreditCardOperation
+
+        def complete!
+          request_id = SecureRandom.uuid
+
+          response = gateway.refund(afterpay_order_id, transaction.amount, request_id)
+
+          if response.success?
+            transaction.response = ActiveMerchant::Billing::Response.new(
+              true,
+              I18n.t(
+                'workarea.afterpay.refund',
+                amount: transaction.amount
+              ),
+              response.body
+            )
+          else
+             transaction.response = ActiveMerchant::Billing::Response.new(
+               false,
+              I18n.t('workarea.afterpay.refund_failure'),
+              response.body
+            )
+          end
+        end
+
+        def cancel!
+          # No op - no cancel functionality available.
+        end
+
+        private
+
+          def gateway
+            currency = transaction.amount.currency.iso_code
+            location = Workarea::Afterpay.config[:currency_country_map][currency.to_sym]
+
+            location = location.to_sym.downcase
+
+            Workarea::Afterpay.gateway(location)
+          end
+
+          def afterpay_order_id
+            transaction.reference.response.params["id"]
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Workarea
+  class Payment
+    class Tender
+      class Afterpay < Tender
+        field :token, type: String
+        field :ready_to_capture, type: Boolean, default: false
+
+        def slug
+          :afterpay
+        end
+
+        def installment_price
+          self.amount / Workarea.config.afterpay[:installment_count]
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/payment.decorator

@@ -0,0 +1,42 @@
+module Workarea
+  decorate Payment, with: :afterpay do
+    decorated do
+      embeds_one :afterpay, class_name: 'Workarea::Payment::Tender::Afterpay'
+    end
+
+    def afterpay?
+      afterpay.present?
+    end
+
+    def set_afterpay(attrs)
+      build_afterpay unless afterpay
+      afterpay.attributes = attrs.slice(
+        :token
+      )
+
+      save
+    end
+
+    def clear_afterpay
+      self.afterpay = nil
+      save
+    end
+
+    def set_credit_card(*)
+      self.afterpay = nil
+      super
+    end
+
+    def authorize!(options = {})
+      transactions = tenders.map { |t| t.build_transaction(action: payment_action(t)) }
+      perform_operation(transactions, options)
+    end
+
+    private
+
+      def payment_action(tender)
+        tender.slug == :afterpay ? 'purchase' : 'authorize'
+      end
+
+  end
+end

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

@@ -0,0 +1,107 @@
+module Workarea
+  module Afterpay
+    class OrderBuilder
+
+      attr_reader :order
+
+      # @param  ::Workarea::Order
+      def initialize(order)
+        @order = Workarea::Storefront::OrderViewModel.new(order)
+      end
+
+      def build
+        {
+          totalAmount: {
+            amount: order.order_balance.to_s,
+            currency: currency_code,
+          },
+          merchantReference: order.id,
+          consumer: {
+            phoneNumber: shipping.address.phone_number,
+            givenNames: shipping.address.first_name,
+            surname: shipping.address.last_name,
+            email: order.email
+          },
+          billing: address(payment.address),
+          shipping: address(shipping.address),
+          items: items,
+          discounts: discounts,
+          merchant: {
+             redirectConfirmUrl: confirm_url,
+             redirectCancelUrl: cancel_url
+          },
+           taxAmount: {
+             amount: order.tax_total.to_s,
+             currency: currency_code
+          },
+          shippingAmount: {
+              amount: order.shipping_total.to_s,
+              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)
+          {
+            name: "#{address_obj.first_name} #{address_obj.last_name}",
+            suburb: address_obj.city,
+            line1: address_obj.street,
+            state: address_obj.region,
+            postcode: address_obj.postal_code,
+            countryCode: address_obj.country.alpha2,
+            phoneNumber:  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: oi.original_unit_price.to_s,
+                currency: currency_code
+              }
+            }
+          end
+        end
+
+        def discounts
+          discounts = order.price_adjustments.select { |p| p.discount? }
+          discounts.map do |d|
+            {
+              displayName: d.description,
+              amount: {
+                amount: d.amount.abs.to_s,
+                currency: currency_code
+              }
+            }
+          end
+        end
+
+        def confirm_url
+          Storefront::Engine.routes.url_helpers.complete_afterpay_url(host: Workarea.config.host)
+        end
+
+        def cancel_url
+          Storefront::Engine.routes.url_helpers.cancel_afterpay_url(host: Workarea.config.host)
+        end
+    end
+  end
+end