trolley 0.2.14 → 1.0.2

data/lib/trolley/gateways/PaymentGateway.rb

@@ -0,0 +1,42 @@
+require_relative '../Client'
+
+module Trolley
+  class PaymentGateway
+    def initialize(client)
+      @client = client
+    end
+
+    def find(batch_id, payment_id)
+      response = @client.get("/v1/batches/#{batch_id}/payments/#{payment_id}")
+      payment_builder(response)
+    end
+
+    def create(batch_id, body)
+      response = @client.post("/v1/batches/#{batch_id}/payments", body)
+      payment_builder(response)
+    end
+
+    def update(batch_id, payment_id, body)
+      @client.patch("/v1/batches/#{batch_id}/payments/#{payment_id}", body)
+      true
+    end
+
+    def delete(batch_id, payment_id)
+      @client.delete("/v1/batches/#{batch_id}/payments/#{payment_id}")
+      true
+    end
+
+    def search(batch_id, page = 1, page_size = 10, term = '')
+      response = @client.get("/v1/batches/#{batch_id}/payments?page=#{page}&pageSize=#{page_size}&search=#{term}")
+      payments_list_builder(response)
+    end
+
+    def payment_builder(response)
+      Utils::ResponseMapper.build(response, Payment)
+    end
+
+    def payments_list_builder(response)
+      Utils::PaginatedArray.from_response(response, Payment)
+    end
+  end
+end

data/lib/trolley/gateways/RecipientAccountGateway.rb

@@ -0,0 +1,42 @@
+require_relative '../Client'
+
+module Trolley
+  class RecipientAccountGateway
+    def initialize(client)
+      @client = client
+    end
+
+    def find(recipient_id, recipient_account_id)
+      response = @client.get("/v1/recipients/#{recipient_id}/accounts/#{recipient_account_id}")
+      recipient_account_builder(response)
+    end
+
+    def all(recipient_id)
+      response = @client.get("/v1/recipients/#{recipient_id}/accounts/")
+      recipient_account_list_builder(response)
+    end
+
+    def create(recipient_id, body)
+      response = @client.post("/v1/recipients/#{recipient_id}/accounts", body)
+      recipient_account_builder(response)
+    end
+
+    def update(recipient_id, recipient_account_id, body)
+      response = @client.patch("/v1/recipients/#{recipient_id}/accounts/#{recipient_account_id}", body)
+      recipient_account_builder(response)
+    end
+
+    def delete(recipient_id, recipient_account_id)
+      @client.delete("/v1/recipients/#{recipient_id}/accounts/#{recipient_account_id}")
+      true
+    end
+
+    def recipient_account_builder(response)
+      Utils::ResponseMapper.build(response, RecipientAccount)
+    end
+
+    def recipient_account_list_builder(response)
+      Utils::PaginatedArray.from_response(response, RecipientAccount)
+    end
+  end
+end

data/lib/trolley/gateways/RecipientGateway.rb

@@ -0,0 +1,82 @@
+require_relative '../Client'
+
+module Trolley
+  class RecipientGateway
+    def initialize(client)
+      @client = client
+    end
+
+    def find(recipient_id)
+      response = @client.get("/v1/recipients/#{recipient_id}")
+      recipient_builder(response)
+    end
+
+    def create(body)
+      response = @client.post('/v1/recipients/', body)
+      recipient_builder(response)
+    end
+
+    def update(recipient_id, body)
+      @client.patch("/v1/recipients/#{recipient_id}", body)
+      true
+    end
+
+    # @param recipient_id [String] or [Array] The id (or array of ids) of the recipient to delete
+    def delete(recipient_id)
+      path = '/v1/recipients/'
+      body = ''
+
+      if recipient_id.is_a?(String)
+        path += recipient_id
+      elsif recipient_id.is_a?(Array)
+        body = { ids: recipient_id }
+      else
+        raise 'Invalid recipient_id type'
+      end
+
+      @client.delete(path, body)
+      true
+    end
+
+    # @note This method retrieves a list of activity logs for a recipient
+    def find_logs(recipient_id)
+      response = @client.get("/v1/recipients/#{recipient_id}/logs")
+      JSON.parse(response, object_class: OpenStruct)
+    end
+
+    def find_payments(recipient_id, page = 1, page_size = 10)
+      query_string = URI.encode_www_form(
+        page: page.to_s,
+        pageSize: page_size.to_s
+      )
+      response = @client.get("/v1/recipients/#{recipient_id}/payments?#{query_string}")
+      payments_list_builder(response)
+    end
+
+    # TODO: if we can afford a breaking change ideally these should be kwargs
+    # rubocop:disable Metrics/ParameterLists
+    def search(page = 1, page_size = 10, prefix_search = '', filters = {})
+      query_string = URI.encode_www_form(
+        page: page.to_s,
+        pageSize: page_size.to_s,
+        search: prefix_search,
+        **filters
+      )
+      response = @client.get("/v1/recipients?#{query_string}")
+      recipient_list_builder(response)
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    def recipient_builder(response)
+      Utils::ResponseMapper.build(response, Recipient)
+    end
+
+    def recipient_list_builder(response)
+      Utils::PaginatedArray.from_response(response, Recipient)
+    end
+
+    def payments_list_builder(response)
+      Utils::PaginatedArray.from_response(response, Payment)
+    end
+  end
+end

data/lib/trolley/utils/PaginatedArray.rb

@@ -0,0 +1,25 @@
+module Trolley
+  module Utils
+    class PaginatedArray < Array
+      attr_accessor :page, :pages, :records
+
+      def self.from_response(response, klass)
+        data = JSON.parse(response)
+
+        enum = Utils::ResponseMapper.new(response, klass).build
+        page = data.dig('meta', 'page')
+        pages = data.dig('meta', 'pages')
+        records = data.dig('meta', 'records')
+
+        new(enum, page, pages, records)
+      end
+
+      def initialize(enum, page, pages, records)
+        super(enum)
+        @page = page
+        @pages = pages
+        @records = records
+      end
+    end
+  end
+end

data/lib/trolley/utils/ResponseMapper.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Trolley
+  module Utils
+    class ResponseMapper
+      KLASS_TO_RESOURCE_KEY_MAPPERS = {
+        'Trolley::Batch' => { resource: 'batch', collection: 'batches' },
+        'Trolley::Invoice' => { resource: 'invoice', collection: 'invoices' },
+        'Trolley::InvoicePayment' => { resource: 'invoicePayment', collection: 'invoicePayments' },
+        'Trolley::OfflinePayment' => { resource: 'offlinePayment', collection: 'offlinePayments' },
+        'Trolley::Payment' => { resource: 'payment', collection: 'payments' },
+        'Trolley::RecipientAccount' => { resource: 'account', collection: 'accounts' },
+        'Trolley::Recipient' => { resource: 'recipient', collection: 'recipients' },
+        'Trolley::BatchSummary' => { resource: 'batchSummary' }
+      }.freeze
+
+      def self.build(response, klass)
+        new(response, klass).build
+      end
+
+      def initialize(response, klass)
+        @response = response
+        @klass = klass
+        @data = JSON.parse(response)
+      end
+
+      def build
+        if collection?
+          build_collection
+        else
+          build_resource
+        end
+      end
+
+      private
+
+      attr_reader :response, :klass, :data
+
+      def build_collection
+        data[applicable_collection_key].map do |resource_data|
+          build_resource(resource_data)
+        end
+      end
+
+      def build_resource(resource_data = nil)
+        resource_data ||= data[applicable_resource_key]
+        loosely_hydrate_model(resource_data)
+      end
+
+      def loosely_hydrate_model(resource_data)
+        instance = klass.new
+
+        resource_data.each do |k, v|
+          instance.send("#{k}=", v)
+        rescue NoMethodError
+          # TODO: The API is showing non-public attributes, once we remove them from the API response we can re-add this warning.
+          # warn "[PaymentRails] Unknown attribute #{k} for class #{klass_instance.class.name}"
+        end
+
+        instance
+      end
+
+      def collection?
+        data[applicable_collection_key].is_a?(Array)
+      end
+
+      def applicable_collection_key
+        applicable_mapper[:collection]
+      end
+
+      def applicable_resource_key
+        applicable_mapper[:resource]
+      end
+
+      def applicable_mapper
+        KLASS_TO_RESOURCE_KEY_MAPPERS.fetch(klass.to_s)
+      end
+    end
+  end
+end

data/lib/trolley.rb

@@ -1,5 +1,33 @@
-class Trolley
-    def self.hi
-      puts "Future home to Trolley's Ruby SDK"
-    end
-  end
+require 'trolley/Configuration'
+require 'trolley/Gateway'
+
+require 'trolley/gateways/BalanceGateway'
+require 'trolley/gateways/BatchGateway'
+require 'trolley/gateways/PaymentGateway'
+require 'trolley/gateways/RecipientGateway'
+require 'trolley/gateways/RecipientAccountGateway'
+require 'trolley/gateways/OfflinePaymentGateway'
+require 'trolley/gateways/InvoiceGateway'
+require 'trolley/gateways/InvoicePaymentGateway'
+
+require 'trolley/utils/PaginatedArray'
+require 'trolley/utils/ResponseMapper'
+
+require 'trolley/Balance'
+require 'trolley/Batch'
+require 'trolley/BatchSummary'
+require 'trolley/Exceptions'
+require 'trolley/Payment'
+require 'trolley/Recipient'
+require 'trolley/RecipientAccount'
+require 'trolley/OfflinePayment'
+require 'trolley/Invoice'
+require 'trolley/InvoicePayment'
+
+module Trolley
+  VERSION = '1.0.2'.freeze
+
+  def self.client(key, secret, **optionals)
+    Gateway.new(Configuration.new(key, secret, **optionals))
+  end
+end

data/spec/integration/BatchTest.rb

@@ -0,0 +1,126 @@
+require_relative 'helper'
+class BatchTest < Test::Unit::TestCase
+  include ApiClientHelper
+
+  def create_recipient
+    uuid = SecureRandom.uuid.to_s
+    recipient = @client.recipient.create(
+      type: 'individual',
+      firstName: 'Tom',
+      lastName: 'Jones',
+      email: "test.batch#{uuid}@example.com",
+      address: {
+        street1: '123 Wolfstrasse',
+        city: 'Berlin',
+        country: 'DE',
+        postalCode: '123123'
+      }
+    )
+    @client.recipient_account.create(recipient.id, type: 'bank-transfer', currency: 'EUR', country: 'DE', iban: 'DE89 3704 0044 0532 0130 00')
+    recipient
+  end
+
+  def test_create
+    batch = @client.batch.create(sourceCurrency: 'USD', description: 'Integration Test Create')
+    assert_not_nil(batch)
+    assert_not_nil(batch.id)
+
+    batch = @client.batch.all
+    assert_true(batch.count > 0)
+  end
+
+  def test_update
+    batch = @client.batch.create(sourceCurrency: 'USD', description: 'Integration Test Create')
+    assert_not_nil(batch)
+    assert_not_nil(batch.id)
+
+    all = @client.batch.all
+    assert_true(all.count > 0)
+
+    response = @client.batch.update(batch.id, description: 'Integration Update')
+    assert_true(response)
+    findBatch = @client.batch.find(batch.id)
+    assert_equal('Integration Update', findBatch.description)
+    assert_equal('open', batch.status)
+
+    response = @client.batch.delete(batch.id)
+    assert_true(response)
+  end
+
+  def test_create_with_payments
+    recipientAlpha = create_recipient
+    recipientBeta = create_recipient
+
+    batch = @client.batch.create(
+      sourceCurrency: 'USD', description: 'Integration Test Payments', payments: [
+        { targetAmount: '10.00', targetCurrency: 'EUR', recipient: { id: recipientAlpha.id } },
+        { sourceAmount: '10.00', recipient: { id: recipientBeta.id } }
+      ]
+    )
+
+    assert_not_nil(batch)
+    assert_not_nil(batch.id)
+
+    findBatch = @client.batch.find(batch.id)
+    assert_not_nil(findBatch)
+    assert_equal(2, findBatch.totalPayments)
+
+    payments = @client.payment.search(batch.id)
+    payments.each { |item| assert_equal('pending', item.status) }
+  end
+
+  def test_payments
+    batch = @client.batch.create(sourceCurrency: 'USD', description: 'Integration Test Payments')
+    assert_not_nil(batch)
+    assert_not_nil(batch.id)
+
+    recipient = create_recipient
+
+    payment = @client.payment.create(batch.id, sourceAmount: '10.00', recipient: { id: recipient.id })
+
+    assert_not_nil(payment)
+    assert_not_nil(payment.id)
+
+    response = @client.payment.update(batch.id, payment.id, sourceAmount: '20.00')
+    assert_true(response)
+
+    response = @client.payment.delete(batch.id, payment.id)
+    assert_true(response)
+  end
+
+  def test_processing
+    recipientAlpha = create_recipient
+    recipientBeta = create_recipient
+
+    batch = @client.batch.create(
+      sourceCurrency: 'USD', description: 'Integration Test Payments', payments: [
+        { targetAmount: '10.00', targetCurrency: 'EUR', recipient: { id: recipientAlpha.id } },
+        { sourceAmount: '10.00', recipient: { id: recipientBeta.id } }
+      ]
+    )
+    assert_not_nil(batch)
+    assert_not_nil(batch.id)
+
+    summary = @client.batch.summary(batch.id)
+    assert_equal(2, summary.detail['bank-transfer']['count'])
+
+    quote = @client.batch.generate_quote(batch.id)
+    assert_not_nil(quote)
+
+    start = @client.batch.start_processing(batch.id)
+    assert_not_nil(start)
+  end
+
+  def test_delete_multiple
+    batch = @client.batch.create(sourceCurrency: 'USD', description: 'Integration Test Create')
+    assert_not_nil(batch)
+    assert_not_nil(batch.id)
+
+    batch2 = @client.batch.create(sourceCurrency: 'USD', description: 'Integration Test Create')
+    assert_not_nil(batch2)
+    assert_not_nil(batch2.id)
+
+    response = @client.batch.delete([batch.id, batch2.id])
+    assert_true(response)
+  end
+end

data/spec/integration/InvoicePaymentTest.rb

@@ -0,0 +1,92 @@
+require_relative 'helper'
+
+class InvoicePaymentTest < Test::Unit::TestCase
+  include ApiClientHelper
+
+  def create_recipient
+    uuid = SecureRandom.uuid.to_s
+    recipient = @client.recipient.create(
+      type: 'individual',
+      firstName: 'Tom',
+      lastName: 'Jones',
+      email: "test.batch#{uuid}@example.com",
+      address: {
+        street1: '123 Wolfstrasse',
+        city: 'Berlin',
+        country: 'DE',
+        postalCode: '123123'
+      }
+    )
+    @client.recipient_account.create(recipient.id, type: 'bank-transfer', currency: 'EUR', country: 'DE', iban: 'DE89 3704 0044 0532 0130 00')
+    recipient
+  end
+
+  def test_create
+    recipient = create_recipient
+    invoice = @client.invoice.create(recipientId: recipient.id, description: 'Integration Test Invoice Create')
+    assert_not_nil(invoice)
+    assert_not_nil(invoice.id)
+    assert_equal('open', invoice.status)
+
+    invoice_line = @client.invoice.create_line(invoiceId: invoice.id, lines: [{ unitAmount: { value: '2000', currency: 'USD' } }])
+    assert_not_nil(invoice_line.lines)
+    assert_not_nil(invoice_line.lines.first['id'])
+
+    @client.invoice_payment.create(ids: [invoiceId: invoice.id])
+    invoice_payments = @client.invoice_payment.search(invoiceIds: [invoice.id])
+    assert_true(invoice_payments.count > 0)
+
+    findInvoice = @client.invoice.find(invoiceId: invoice.id)
+    assert_equal('paid', findInvoice.status)
+  end
+
+  def test_update
+    recipient = create_recipient
+
+    invoice = @client.invoice.create(recipientId: recipient.id, description: 'Integration Test Invoice Create')
+    assert_not_nil(invoice)
+    assert_not_nil(invoice.id)
+
+    invoices = @client.invoice.search({})
+    assert_true(invoices.count > 0)
+
+    invoice_line = @client.invoice.create_line(invoiceId: invoice.id, lines: [{ unitAmount: { value: '2000', currency: 'USD' } }])
+    assert_not_nil(invoice_line.lines)
+    assert_not_nil(invoice_line.lines.first['id'])
+
+    invoice_payment = @client.invoice_payment.create(ids: [invoiceId: invoice.id])
+    invoice_payments = @client.invoice_payment.search(invoiceIds: [invoice.id])
+    assert_true(invoice_payments.count > 0)
+    assert_equal('2000.00', invoice_payments.first.amount['value'])
+
+    response = @client.invoice_payment.update(paymentId: invoice_payment.paymentId, invoiceLineId: invoice_payment.invoicePayments.first['invoiceLineId'], amount: { value: '5000', currency: 'USD' })
+    assert_true(response)
+    invoice_payments = @client.invoice_payment.search(invoiceIds: [invoice.id])
+    assert_true(invoice_payments.count > 0)
+    assert_equal('5000.00', invoice_payments.first.amount['value'])
+  end
+
+  def test_delete
+    recipient = create_recipient
+
+    invoice = @client.invoice.create(recipientId: recipient.id, description: 'Integration Test Invoice Create')
+    assert_not_nil(invoice)
+    assert_not_nil(invoice.id)
+
+    invoices = @client.invoice.search({})
+    assert_true(invoices.count > 0)
+
+    invoice_line = @client.invoice.create_line(invoiceId: invoice.id, lines: [{ unitAmount: { value: '2000', currency: 'USD' } }])
+    assert_not_nil(invoice_line.lines)
+    assert_not_nil(invoice_line.lines.first['id'])
+
+    invoice_payment = @client.invoice_payment.create(ids: [invoiceId: invoice.id])
+    invoice_payments = @client.invoice_payment.search(invoiceIds: [invoice.id])
+    assert_true(invoice_payments.count > 0)
+
+    response = @client.invoice_payment.delete(paymentId: invoice_payment.paymentId, invoiceLineIds: [invoice_payment.invoicePayments.first['invoiceLineId']])
+    assert_true(response)
+    invoice_payments = @client.invoice_payment.search(invoiceIds: [invoice.id])
+    assert_true(invoice_payments.count == 0)
+  end
+end

data/spec/integration/InvoiceTest.rb

@@ -0,0 +1,128 @@
+require_relative 'helper'
+
+# rubocop:disable Metrics/ClassLength
+class InvoiceTest < Test::Unit::TestCase
+  include ApiClientHelper
+
+  def create_recipient
+    uuid = SecureRandom.uuid.to_s
+    recipient = @client.recipient.create(
+      type: 'individual',
+      firstName: 'Tom',
+      lastName: 'Jones',
+      email: "test.batch#{uuid}@example.com",
+      address: {
+        street1: '123 Wolfstrasse',
+        city: 'Berlin',
+        country: 'DE',
+        postalCode: '123123'
+      }
+    )
+    @client.recipient_account.create(recipient.id, type: 'bank-transfer', currency: 'EUR', country: 'DE', iban: 'DE89 3704 0044 0532 0130 00')
+    recipient
+  end
+
+  def test_create
+    recipient = create_recipient
+    invoice = @client.invoice.create(recipientId: recipient.id, description: 'Integration Test Invoice Create')
+    assert_not_nil(invoice)
+    assert_not_nil(invoice.id)
+
+    invoice = @client.invoice.search({})
+    assert_true(invoice.count > 0)
+  end
+
+  def test_create_line
+    recipient = create_recipient
+    invoice = @client.invoice.create(recipientId: recipient.id, description: 'Integration Test Invoice Create')
+    assert_not_nil(invoice)
+    assert_not_nil(invoice.id)
+    assert_equal([], invoice.lines)
+
+    invoice_line = @client.invoice.create_line(invoiceId: invoice.id, lines: [{ unitAmount: { value: '2000', currency: 'USD' } }])
+    assert_not_nil(invoice_line.lines)
+    assert_not_nil(invoice_line.lines.first['id'])
+
+    findInvoice = @client.invoice.find(invoiceId: invoice.id)
+    assert_true(findInvoice.lines.count > 0)
+  end
+
+  def test_update
+    recipient = create_recipient
+    invoice = @client.invoice.create(recipientId: recipient.id, description: 'Integration Test Invoice Create')
+    assert_not_nil(invoice)
+    assert_not_nil(invoice.id)
+
+    invoices = @client.invoice.search({})
+    assert_true(invoices.count > 0)
+
+    response = @client.invoice.update(invoiceId: invoice.id, description: 'Integration Test Invoice Update')
+    assert_true(response)
+    findInvoice = @client.invoice.find(invoiceId: invoice.id)
+    assert_equal('Integration Test Invoice Update', findInvoice.description)
+    assert_equal('open', findInvoice.status)
+  end
+
+  def test_update_line
+    recipient = create_recipient
+    invoice = @client.invoice.create(recipientId: recipient.id, description: 'Integration Test Invoice Create')
+    assert_not_nil(invoice)
+    assert_not_nil(invoice.id)
+    assert_equal([], invoice.lines)
+
+    invoice_line = @client.invoice.create_line(invoiceId: invoice.id, lines: [{ unitAmount: { value: '2000', currency: 'USD' } }])
+    assert_not_nil(invoice_line.lines)
+    assert_not_nil(invoice_line.lines.first['id'])
+
+    response = @client.invoice.update_line(
+      invoiceId: invoice.id,
+      lines: [{
+        invoiceLineId: invoice_line.lines.first['id'],
+        unitAmount: { value: '3000', currency: 'USD' }
+      }]
+    )
+    assert_true(response)
+
+    findInvoice = @client.invoice.find(invoiceId: invoice.id)
+    assert_equal('3000.00', findInvoice.lines.first['unitAmount']['value'])
+  end
+
+  def test_delete
+    recipient = create_recipient
+    invoice = @client.invoice.create(recipientId: recipient.id, description: 'Integration Test Invoice Create')
+    assert_not_nil(invoice)
+    assert_not_nil(invoice.id)
+
+    invoices = @client.invoice.search({})
+    assert_true(invoices.count > 0)
+
+    response = @client.invoice.delete(invoiceIds: invoices.map(&:id))
+    assert_true(response)
+
+    final_invoices = @client.invoice.search({})
+    assert_true(final_invoices.count == 0)
+  end
+
+  def test_delete_line
+    recipient = create_recipient
+    invoice = @client.invoice.create(recipientId: recipient.id, description: 'Integration Test Invoice Create')
+    assert_not_nil(invoice)
+    assert_not_nil(invoice.id)
+    assert_equal([], invoice.lines)
+
+    invoice_line = @client.invoice.create_line(invoiceId: invoice.id, lines: [{ unitAmount: { value: '2000', currency: 'USD' } }])
+
+    response = @client.invoice.delete_line(invoiceId: invoice.id, invoiceLineIds: [invoice_line.lines.first['id']])
+    assert_true(response)
+  end
+
+  def test_support_error_arrays
+    @client.invoice.create(recipientId: 'invalid', description: 'Integration Test Invoice Create')
+  rescue ::Trolley::TrolleyError => e
+    assert_equal(1, e.validation_errors.count)
+    assert_equal('recipientId', e.validation_errors.first['field'])
+    assert_equal('Value is invalid', e.validation_errors.first['message'])
+    assert_equal('invalid_field', e.validation_errors.first['code'])
+  end
+end
+# rubocop:enable Metrics/ClassLength