afterpay-sdk 2.0.0

data/lib/afterpay/discount.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Afterpay
+  class Discount
+    attr_accessor :name, :amount
+
+    def initialize(name:, amount:)
+      @name = name
+      @amount = amount
+    end
+
+    def to_hash
+      {
+        displayName: name,
+        amount: Utils::Money.api_hash(amount)
+      }
+    end
+
+    def self.from_response(response)
+      return nil if response.nil?
+
+      new(
+        name: response[:display_name],
+        amount: Utils::Money.from_response(response[:amount])
+      )
+    end
+  end
+end

data/lib/afterpay/error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Afterpay
+  # Error class with accessor to methods
+  # Afterpay error returns the same format containing
+  # `errorId`, `errorCode`, `message`
+  class Error
+    attr_accessor :code, :id, :message
+
+    def initialize(response)
+      @id = response[:errorId]
+      @code = response[:errorCode]
+      @message = response[:message]
+    end
+  end
+end

data/lib/afterpay/item.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "money"
+
+module Afterpay
+  class Item
+    attr_accessor :name, :sku, :quantity, :page_url, :image_url, :price, :categories, :estimated_shipment_date
+
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(name:, price:, page_url:, image_url:, categories:, estimated_shipment_date:, sku: nil, quantity: 1)
+      @name = name
+      @sku = sku
+      @quantity = quantity
+      @price = price
+      @page_url = page_url
+      @image_url = image_url
+      @categories = categories
+      @estimated_shipment_date = estimated_shipment_date
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    def to_hash
+      {
+        name: name,
+        sku: sku,
+        quantity: quantity,
+        price: {
+          amount: price.amount.to_f,
+          currency: price.currency.iso_code
+        },
+        page_url: page_url,
+        image_url: image_url,
+        categories: categories,
+        estimated_shipment_date: estimated_shipment_date
+      }
+    end
+
+    # Builds Item from response
+    def self.from_response(response)
+      return nil if response.nil?
+
+      new(
+        name: response[:name],
+        sku: response[:sku],
+        quantity: response[:quantity],
+        price: Utils::Money.from_response(response[:price]),
+        page_url: response[:pageUrl],
+        image_url: response[:imageUrl],
+        categories: response[:categories],
+        estimated_shipment_date: response[:estimatedShipmentDate]
+      )
+    end
+  end
+end

data/lib/afterpay/order.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Afterpay
+  # The Order object for creating an order to `/v2/checkouts`
+  class Order
+    attr_accessor :total, :consumer, :items, :shipping, :tax, :discounts,
+                  :billing, :shipping_address, :billing_address, :reference,
+                  :payment_type, :success_url, :cancel_url, :redirect_checkout_url
+
+    attr_reader :expiry, :token, :error
+
+    # Finds Order from Afterpay API
+    # @param token [String]
+    # @return [Order]
+    def self.find(token)
+      request = Afterpay.client.get("/v2/checkouts/#{token}")
+
+      Order.from_response(request.body)
+    end
+
+    # Builds Order from response
+    # @param response [Hash] response params from API
+    # @return [Order]
+    def self.from_response(response)
+      return nil if response.nil?
+
+      new(
+        total: Utils::Money.from_response(response[:total]),
+        consumer: Consumer.from_response(response[:consumer]),
+        items: response[:items].map { |item| Item.from_response(item) },
+        billing_address: Address.from_response(response[:billing]),
+        shipping_address: Address.from_response(response[:shipping]),
+        discounts: response[:discounts].map { |discount| Discount.from_response(discount) },
+        tax: Utils::Money.from_response(response[:taxAmount]),
+        shipping: Utils::Money.from_response(response[:shippingAmount])
+      )
+    end
+
+    # Helper function to create an Order and calls #create
+    #
+    # @param (see #initialize)
+    # @return [Order::Response] containing token, error, valid?
+    def self.create(*args)
+      new(*args).create
+    end
+
+    # Initializes an Order object
+    #
+    # @overload initialize(total:, items:, consumer:, success_url:, cancel_url:, payment_type:)
+    #   @param total [Money] a Money object
+    #   @param items [Array<Afterpay::Item>] receives items for order
+    #   @param consumer [Afterpay::Consume] the consumer for the order
+    #   @param success_url [String] the path to redirect on successful payment
+    #   @param cancel_url [String] the path to redirect on failed payment
+    #   @param payment_type [String] Payment type defaults to {Config#type}
+    #   @param shipping [Money] optional the billing Address
+    #   @param discounts [Array<Afterpay::Discount>] optional discounts
+    #   @param billing_address [<Afterpay::Address>] optional the billing Address
+    #   @param shipping_address [<Afterpay::Address>] optional the shipping Address
+    def initialize(attributes = {})
+      attributes.each { |key, value| instance_variable_set(:"@#{key}", value) }
+      @apayment_type ||= Afterpay.config.type
+      @token ||= nil
+      @expiry ||= nil
+      @error = nil
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
+
+    # Builds structure to API specs
+    def to_hash
+      data = {
+        amount: Utils::Money.api_hash(total),
+        consumer: consumer.to_hash,
+        merchant: {
+          redirectConfirmUrl: success_url,
+          redirectCancelUrl: cancel_url
+        },
+        merchantReference: reference,
+        taxAmount: tax,
+        paymentType: payment_type
+      }
+      data[items] = items.map(&:to_hash) if items
+      data[:taxAmount] = Utils::Money.api_hash(tax) if tax
+      data[:shippingAmount] = Utils::Money.api_hash(shipping) if shipping
+      data[:discounts] = discounts.map(&:to_hash) if discounts
+      data[:billing] = billing_address.to_hash if billing_address
+      data[:shipping] = shipping_address.to_hash if shipping_address
+      data
+    end
+
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    # Sends the create request to Afterpay server
+    # @return [Response]
+    def create
+      request = Afterpay.client.post("/v2/checkouts") do |req|
+        req.body = to_hash
+      end
+      response = request.body
+      if request.success?
+        @expiry = response[:expires]
+        @token = response[:token]
+        @redirect_checkout_url = response[:redirectCheckoutUrl]
+      else
+        @error = Error.new(response)
+      end
+      self
+    end
+
+    def success?
+      !@token.nil?
+    end
+  end
+end

data/lib/afterpay/payment.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ClassLength
+
+module Afterpay
+  # They Payment object
+  class Payment
+    attr_accessor :id, :token, :status, :created, :original_amount, :open_to_capture_amount,
+                  :payment_state, :merchant_reference, :refunds, :order, :events, :error
+
+    # Initialize Payment from response
+    def initialize(attributes)
+      @id = attributes[:id].to_i
+      @token = attributes[:token]
+      @status = attributes[:status]
+      @created = attributes[:created]
+      @original_amount = Utils::Money.from_response(attributes[:originalAmount])
+      @open_to_capture_amount = Utils::Money.from_response(attributes[:openToCaptureAmount])
+      @payment_state = attributes[:paymentState]
+      @merchant_reference = attributes[:merchantReference]
+      @refunds = attributes[:refunds]
+      @order = Order.from_response(attributes[:orderDetails])
+      @events = attributes[:events]
+      @error = Error.new(attributes) if attributes[:errorId]
+    end
+
+    def success?
+      @status == "APPROVED"
+    end
+
+    # Executes the Payment
+    #
+    # @param token [String] the Order token
+    # @param reference [String] the reference for payment
+    # @return [Payment] the Payment object
+    def self.execute(token:, reference:)
+      request = Afterpay.client.post("/v2/payments/capture") do |req|
+        req.body = {
+          token: token,
+          merchantRefernce: reference
+        }
+      end
+      new(request.body)
+    end
+
+    def self.execute_auth(request_id:, token:, merchant_reference:)
+      request = Afterpay.client.post("/v2/payments/auth") do |req|
+        req.body = {
+          requestId: request_id,
+          token: token,
+          merchantReference: merchant_reference
+        }
+      end
+      new(request.body)
+    end
+
+    def self.execute_deferred_payment(request_id:, reference:, amount:,
+                                      payment_event_merchant_reference:, order_id:)
+      request = Afterpay.client.post("/v2/payments/#{order_id}/capture") do |req|
+        req.body = {
+          requestId: request_id,
+          merchantRefernce: reference,
+          amount: Utils::Money.api_hash(amount),
+          paymentEventMerchantReference: payment_event_merchant_reference
+        }
+      end
+      new(request.body)
+    end
+
+    def self.execute_void(request_id:, order_id:, amount:)
+      request = Afterpay.client.post("/v2/payments/#{order_id}/void") do |req|
+        req.body = {
+          requestId: request_id,
+          amount: Utils::Money.api_hash(amount)
+        }
+      end
+      new(request.body)
+    end
+
+    def self.update_shipping_courier(order_id:, shipped_at:, name:, tracking:, priority:)
+      request = Afterpay.client.put("/v2/payments/#{order_id}/courier") do |req|
+        req.body = {
+          shippedAt: shipped_at,
+          name: name,
+          tracking: tracking,
+          priority: priority
+        }
+      end
+      new(request.body)
+    end
+
+    # This endpoint retrieves an individual payment along with its order details.
+    def self.get_payment_by_order_id(order_id:)
+      request = Afterpay.client.get("/v2/payments/#{order_id}")
+      new(request.body)
+    end
+
+    # This endpoint retrieves an individual payment along with its order details.
+    def self.get_payment_by_token(token:)
+      request = Afterpay.client.get("/v2/payments/token:#{token}")
+      new(request.body)
+    end
+
+    # This end point is for merchants that creates merchant side's order id after
+    # AfterPay order id creation. The merchants should call immediately after the
+    # AfterPay order is created in order to properly update with their order id
+    # that can be tracked.
+    def self.update_payment_by_order_id(order_id:, merchant_reference:)
+      request = Afterpay.client.put("/v2/payments/#{order_id}") do |req|
+        req.body = {
+          # The merchant's new order id to replace with
+          merchantReference: merchant_reference
+        }
+      end
+      request.body
+    end
+
+    # This endpoint performs a reversal of the checkout that is used to initiate
+    # the Afterpay payment process. This will cancel the order asynchronously as
+    # soon as it is created without the need of an additional call to the void endpoint.
+    # In order for a payment to be eligible, the order must be in an Auth-Approved or
+    # Captured state and must be issued within 10 minutes of the order being created.
+    # token paramater is the token of the checkout to be reversed (voided).
+    def self.reverse_payment_by_token(token:)
+      request = Afterpay.client.post("/v2/payments/token:#{token}/reversal") do |req|
+        req.body = {}
+      end
+      request.status
+    end
+
+    def self.create_url(url, type, values)
+      if values.size.positive?
+        values.each do |value|
+          url += "&#{type}=#{value}"
+        end
+      end
+      url
+    end
+
+    # rubocop:disable Metrics/ParameterLists
+
+    # This endpoint retrieves a collection of payments along with their order details.
+    def self.list_payments(to_created_date:, from_created_date:, limit:, offset:, tokens:, ids:,
+                           merchant_ref:, statuses:, order_by:, asc:)
+      url = "/v2/payments?"
+      url += "toCreatedDate=#{to_created_date.gsub('+', '%2b')}" if to_created_date
+      url += "&fromCreatedDate=#{from_created_date.gsub('+', '%2b')}" if from_created_date
+      url += "&limit=#{limit}" if limit
+      url += "&offset=#{offset}" if offset
+      url += "&orderBy=#{order_by}" if order_by
+      url += "&ascending=#{asc}" if asc
+      url += create_url(url, "ids", ids)
+      url += create_url(url, "tokens", tokens)
+      url += create_url(url, "merchantReferences", merchant_ref)
+      url += create_url(url, "statuses", statuses)
+      request = Afterpay.client.get(url)
+      request.body
+    end
+
+    # rubocop:enable Metrics/ParameterLists
+  end
+end
+
+# rubocop:enable Metrics/ClassLength

data/lib/afterpay/payment_event.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Afterpay
+  class PaymentEvent
+    attr_accessor :id, :created, :expires, :type, :amount, :payment_event_merchant_reference
+
+    def initialize(attributes)
+      @id = attributes[:id]
+      @created = attributes[:created]
+      @expires = attributes[:expires]
+      @type = attributes[:expires]
+      @amount = Utils::Money.from_response(attributes[:amount])
+      @payment_event_merchant_reference = attributes[:paymentEventMerchantReference]
+    end
+  end
+end

data/lib/afterpay/refund.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Afterpay
+  class Refund
+    attr_accessor :request_id, :amount, :merchant_reference, :refund_id, :refunded_at,
+                  :refund_merchant_reference, :error
+
+    def initialize(attributes)
+      @request_id = attributes[:requestId]
+      @amount = attributes[:amount]
+      @merchant_reference = attributes[:merchantReference]
+      @refund_id = attributes[:refundId]
+      @refunded_at = attributes[:refundAt]
+      @refund_merchant_reference = attributes[:refundMerchantReference]
+      @error = Error.new(attributes) if attributes[:errorId]
+    end
+
+    def self.execute(request_id:, order_id:, amount:, merchant_reference:,
+                     refund_merchant_reference:)
+      request = Afterpay.client.post("/v2/payments/#{order_id}/refund") do |req|
+        req.body = {
+          requestId: request_id,
+          amount: Utils::Money.api_hash(amount),
+          merchantReference: merchant_reference,
+          refundMerchantReference: refund_merchant_reference
+        }
+      end
+      new(request.body)
+    end
+  end
+end

data/lib/afterpay/shipping_courier.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Afterpay
+  class ShippingCourier
+    attr_accessor :shipped_at, :name, :tracking, :priority
+
+    def initialize(shipped_at:, name:, tracking:, priority:)
+      @shipped_at = shipped_at
+      @name = name
+      @tracking = tracking
+      @priority = priority
+    end
+  end
+end