unit_ruby_sdk 1.0.5 → 1.2.0

data/lib/unit/models/payment/create_batch_release_request.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Request to create a batch release
+# @see https://docs.unit.co/batch-payments/#create-batch-releases
+module Unit
+  module Payment
+    class CreateBatchReleaseRequest
+      attr_reader :account_id, :batch_account_id, :amount, :description, :sender_name, :sender_address,
+                  :sender_account_number, :tags, :idempotency_key
+
+      # @param account_id [String]
+      # @param batch_account_id [String]
+      # @param amount [Integer]
+      # @param description [String]
+      # @param sender_name [String]
+      # @param sender_address [Address]
+      # @param sender_account_number [String]
+      # @param tags [Hash] - optional
+      # @param idempotency_key [String] - optional
+      def initialize(account_id, batch_account_id, amount, description, sender_name, sender_address, sender_account_number, tags = nil, idempotency_key = nil)
+        @account_id = account_id
+        @batch_account_id = batch_account_id
+        @amount = amount
+        @description = description
+        @sender_name = sender_name
+        @sender_address = sender_address
+        @sender_account_number = sender_account_number
+        @tags = tags
+        @idempotency_key = idempotency_key
+      end
+
+      def to_hash
+        payload = {
+          "type": "batchRelease",
+          "attributes": {
+            "amount": amount,
+            "description": description,
+            "senderName": sender_name,
+            "senderAddress": sender_address&.represent,
+            "senderAccountNumber": sender_account_number,
+            "tags": tags,
+            "idempotencyKey": idempotency_key
+          },
+          "relationships": {
+            "batchAccount": Unit::Types::Relationship.new("batchAccount", batch_account_id).to_hash,
+            "receiver": Unit::Types::Relationship.new("depositAccount", account_id).to_hash
+          }
+        }
+        payload[:attributes].compact!
+        payload
+      end
+    end
+  end
+end

data/lib/unit/models/payment/create_book_payment_request.rb

@@ -14,8 +14,8 @@ module Unit
       # @param transaction_summary_override [String] - optional
       # @param idempotency_key [String] - optional
       # @param tags [Hash] - optional
-      def initialize(amount, description, account_id, counterparty_account_id, transaction_summary_override = nil,
-                     idempotency_key = nil, tags = nil)
+      def initialize(amount:, description:, account_id:, counterparty_account_id:, transaction_summary_override: nil,
+                     idempotency_key: nil, tags: nil)
         @amount = amount
         @description = description
         @account_id = account_id
@@ -27,22 +27,32 @@ module Unit
 
       def to_json_api
         payload = {
-          data: {
-            type: "bookPayment",
-            attributes: {
-              amount: amount,
-              description: description,
-              transactionSummaryOverride: transaction_summary_override,
-              idempotencyKey: idempotency_key,
-              tags: tags
-            },
-            relationships: { account: Unit::Types::Relationship.new("depositAccount", account_id).to_hash,
-                             counterpartyAccount: Unit::Types::Relationship.new("depositAccount", counterparty_account_id).to_hash }
-          }
+          data: to_hash
         }
         payload[:data][:attributes].compact!
         payload.to_json
       end
+
+      def to_hash
+        {
+          type: "bookPayment",
+          attributes: {
+            amount: amount,
+            description: description,
+            transactionSummaryOverride: transaction_summary_override,
+            idempotencyKey: idempotency_key,
+            tags: tags
+          },
+          relationships: { account: Unit::Types::Relationship.new("depositAccount", account_id).to_hash,
+                           counterpartyAccount: Unit::Types::Relationship.new("depositAccount", counterparty_account_id).to_hash }
+        }
+      end
+
+      def change_attributes
+        payload = to_hash
+        payload[:attributes].compact!
+        payload
+      end
     end
   end
 end

data/lib/unit/models/payment/create_payment_linked_request.rb

@@ -20,9 +20,9 @@ module Unit
       # @param verify_counterparty_balance [Boolean] - optional
       # @param same_day [Boolean] - optional
       # @param sec_code [String] - optional
-      def initialize(account_id, counterparty_id, amount, direction, description,
-                     addenda = nil, idempotency_key = nil, tags = nil, verify_counterparty_balance = nil,
-                     same_day = nil, sec_code = nil)
+      def initialize(account_id:, counterparty_id:, amount:, direction:, description:,
+                     addenda: nil, idempotency_key: nil, tags: nil, verify_counterparty_balance: nil,
+                     same_day: nil, sec_code: nil)
         @account_id = account_id
         @counterparty_id = counterparty_id
         @amount = amount
@@ -38,28 +38,38 @@ module Unit
 
       def to_json_api
         payload = {
-          "data": {
-            "type": "achPayment",
-            "attributes": {
-              amount: amount,
-              direction: direction,
-              description: description,
-              addenda: addenda,
-              idempotencyKey: idempotency_key,
-              tags: tags,
-              verifyCounterpartyBalance: verify_counterparty_balance,
-              sameDay: same_day,
-              secCode: sec_code
-            },
-            "relationships": {
-              "account": Unit::Types::Relationship.new("account", account_id).to_hash,
-              "counterparty": Unit::Types::Relationship.new("counterparty", counterparty_id).to_hash
-            }
-          }
+          "data": to_hash
         }
         payload[:data][:attributes].compact!
         payload.to_json
       end
+
+      def to_hash
+        {
+          "type": "achPayment",
+          "attributes": {
+            amount: amount,
+            direction: direction,
+            description: description,
+            addenda: addenda,
+            idempotencyKey: idempotency_key,
+            tags: tags,
+            verifyCounterpartyBalance: verify_counterparty_balance,
+            sameDay: same_day,
+            secCode: sec_code
+          },
+          "relationships": {
+            "account": Unit::Types::Relationship.new("account", account_id).to_hash,
+            "counterparty": Unit::Types::Relationship.new("counterparty", counterparty_id).to_hash
+          }
+        }
+      end
+
+      def change_attributes
+        payload = to_hash
+        payload[:attributes].compact!
+        payload
+      end
     end
   end
 end

data/lib/unit/models/payment/create_wire_payment_request.rb

@@ -13,7 +13,7 @@ module Unit
       # @param counterparty [WireCounterparty]
       # @param idempotency_key [String] - optional
       # @param tags [Hash] - optional
-      def initialize(account_id, amount, description, counterparty, idempotency_key = nil, tags = nil)
+      def initialize(account_id:, amount:, description:, counterparty:, idempotency_key: nil, tags: nil)
         @account_id = account_id
         @amount = amount
         @description = description
@@ -24,21 +24,31 @@ module Unit
 
       def to_json_api
         payload = {
-          data: {
-            type: "wirePayment",
-            attributes: {
-              amount: amount,
-              description: description,
-              counterparty: counterparty.represent,
-              idempotencyKey: idempotency_key,
-              tags: tags
-            },
-            relationships: { account: Unit::Types::Relationship.new("account", account_id).to_hash }
-          }
+          data: to_hash
         }
         payload[:data][:attributes].compact!
         payload.to_json
       end
+
+      def to_hash
+        {
+          type: "wirePayment",
+          attributes: {
+            amount: amount,
+            description: description,
+            counterparty: counterparty.represent,
+            idempotencyKey: idempotency_key,
+            tags: tags
+          },
+          relationships: { account: Unit::Types::Relationship.new("account", account_id).to_hash }
+        }
+      end
+
+      def change_attributes
+        payload = to_hash
+        payload[:attributes].compact!
+        payload
+      end
     end
   end
 end

data/lib/unit/models/payment/create_with_plaid_token_request.rb

@@ -22,9 +22,9 @@ module Unit
       # @param verify_counterparty_balance [Boolean] - optional
       # @param same_day [Boolean] - optional
       # @param sec_code [String] - optional
-      def initialize(account_id, amount, direction, description, plaid_processor_token,
-                     addenda = nil, idempotency_key = nil, counterparty_name = nil, tags = nil,
-                     verify_counterparty_balance = nil, same_day = nil, sec_code = nil)
+      def initialize(account_id:, amount:, direction:, description:, plaid_processor_token:,
+                     addenda: nil, idempotency_key: nil, counterparty_name: nil, tags: nil,
+                     verify_counterparty_balance: nil, same_day: nil, sec_code: nil)
         @account_id = account_id
         @amount = amount
         @direction = direction
@@ -41,29 +41,39 @@ module Unit
 
       def to_json_api
         payload = {
-          "data": {
-            "type": "achPayment",
-            "attributes": {
-              amount: amount,
-              direction: direction,
-              description: description,
-              plaidProcessorToken: plaid_processor_token,
-              addenda: addenda,
-              idempotencyKey: idempotency_key,
-              counterpartyName: counterparty_name,
-              tags: tags,
-              verifyCounterpartyBalance: verify_counterparty_balance,
-              sameDay: same_day,
-              secCode: sec_code
-            },
-            "relationships": {
-              "account": Unit::Types::Relationship.new("account", account_id).to_hash
-            }
-          }
+          "data": to_hash
         }
         payload[:data][:attributes].compact!
         payload.to_json
       end
+
+      def to_hash
+        {
+          "type": "achPayment",
+          "attributes": {
+            amount: amount,
+            direction: direction,
+            description: description,
+            plaidProcessorToken: plaid_processor_token,
+            addenda: addenda,
+            idempotencyKey: idempotency_key,
+            counterpartyName: counterparty_name,
+            tags: tags,
+            verifyCounterpartyBalance: verify_counterparty_balance,
+            sameDay: same_day,
+            secCode: sec_code
+          },
+          "relationships": {
+            "account": Unit::Types::Relationship.new("account", account_id).to_hash
+          }
+        }
+      end
+
+      def change_attributes
+        payload = to_hash
+        payload[:attributes].compact!
+        payload
+      end
     end
   end
 end

data/lib/unit/models/payment/payment.rb

@@ -13,6 +13,9 @@ module Unit
     autoload :CreateWirePaymentRequest, "unit/models/payment/create_wire_payment_request"
     autoload :ListPaymentParams, "unit/models/payment/list_payment_params"
     autoload :GetRequest, "unit/models/payment/get_request"
+    autoload :BulkPaymentRequest, "unit/models/payment/bulk_payment_request"
+    autoload :CreateBatchReleaseRequest, "unit/models/payment/create_batch_release_request"
+    autoload :BatchReleaseRequestBuilder, "unit/models/payment/batch_release_request_builder"
     class << self
       # Create a new book payment by calling Unit's API
       # @see https://docs.unit.co/book-payments#book-payments
@@ -26,8 +29,9 @@ module Unit
       # @return [UnitResponse, UnitError]
       def create_book_payment(amount:, description:, account_id:, counterparty_account_id:, transaction_summary_override: nil,
                               idempotency_key: nil, tags: nil)
-        request = Unit::Payment::CreateBookPaymentRequest.new(amount, description, account_id, counterparty_account_id, transaction_summary_override,
-                                                              idempotency_key, tags)
+        request = Unit::Payment::CreateBookPaymentRequest.new(amount: amount, description: description, account_id: account_id, counterparty_account_id: counterparty_account_id, transaction_summary_override: transaction_summary_override,
+                                                              idempotency_key: idempotency_key, tags: tags)
+
         Unit::Resource::PaymentResource.create_payment(request)
       end
 
@@ -56,8 +60,8 @@ module Unit
       def create_ach_payment_inline(account_id:, amount:, direction:, counterparty:,
                                     description:, addenda: nil, idempotency_key: nil, tags: nil,
                                     same_day: nil, sec_code: nil)
-        request = Unit::Payment::CreateAchPaymentInlineRequest.new(account_id, amount, direction, counterparty, description,
-                                                                   addenda, idempotency_key, tags, same_day, sec_code)
+        request = Unit::Payment::CreateAchPaymentInlineRequest.new(account_id: account_id, amount: amount, direction: direction, counterparty: counterparty, description: description, addenda: addenda, idempotency_key: idempotency_key,
+                                                                   tags: tags, same_day: same_day, sec_code: sec_code)
         Unit::Resource::PaymentResource.create_payment(request)
       end
 
@@ -77,9 +81,8 @@ module Unit
       def create_ach_payment_linked(account_id:, counterparty_id:, amount:, direction:,
                                     description:, addenda: nil, idempotency_key: nil, tags: nil,
                                     verify_counterparty_balance: nil, same_day: nil, sec_code: nil)
-        request = Unit::Payment::CreatePaymentLinkedRequest.new(account_id, counterparty_id, amount, direction,
-                                                                description, addenda, idempotency_key, tags,
-                                                                verify_counterparty_balance, same_day, sec_code)
+        request = Unit::Payment::CreatePaymentLinkedRequest.new(account_id: account_id, counterparty_id: counterparty_id, amount: amount, direction: direction, description: description, addenda: addenda, idempotency_key: idempotency_key,
+                                                                tags: tags, verify_counterparty_balance: verify_counterparty_balance, same_day: same_day, sec_code: sec_code)
         Unit::Resource::PaymentResource.create_payment(request)
       end
 
@@ -100,9 +103,8 @@ module Unit
       def create_ach_payment_with_plaid_token(account_id:, amount:, direction:, description:, plaid_processor_token:,
                                               addenda: nil, idempotency_key: nil, counterparty_name: nil, tags: nil,
                                               verify_counterparty_balance: nil, same_day: nil, sec_code: nil)
-        request = Unit::Payment::CreateWithPlaidTokenRequest.new(account_id, amount, direction, description, plaid_processor_token,
-                                                                 addenda, idempotency_key, counterparty_name, tags,
-                                                                 verify_counterparty_balance, same_day, sec_code)
+        request = Unit::Payment::CreateWithPlaidTokenRequest.new(account_id: account_id, amount: amount, direction: direction, description: description, plaid_processor_token: plaid_processor_token, addenda: addenda, idempotency_key: idempotency_key,
+                                                                 counterparty_name: counterparty_name, tags: tags, verify_counterparty_balance: verify_counterparty_balance, same_day: same_day, sec_code: sec_code)
         Unit::Resource::PaymentResource.create_payment(request)
       end
 
@@ -131,7 +133,7 @@ module Unit
       # @param idempotency_key [String] - optional
       # @param tags [Hash] - optional
       def create_wire_payment(account_id:, amount:, description:, counterparty:, idempotency_key: nil, tags: nil)
-        request = Unit::Payment::CreateWirePaymentRequest.new(account_id, amount, description, counterparty, idempotency_key, tags)
+        request = Unit::Payment::CreateWirePaymentRequest.new(account_id: account_id, amount: amount, description: description, counterparty: counterparty, idempotency_key: idempotency_key, tags: tags)
         Unit::Resource::PaymentResource.create_payment(request)
       end
 
@@ -173,6 +175,32 @@ module Unit
         request = Unit::Payment::GetRequest.new(payment_id, include)
         Unit::Resource::PaymentResource.get_payment(request)
       end
-    end
+
+      # Create a bulk payment by calling Unit's API
+      # @see https://docs.unit.co/payments/#bulk-payments
+      # @param requests [Array<CreateAchPaymentInlineRequest, CreatePaymentLinkedRequest, CreateBookPaymentRequest, CreateWithPlaidTokenRequest, CreateWirePaymentRequest>]
+      def create_bulk_payment(requests:)
+        request = Unit::Payment::BulkPaymentRequest.serialize(requests)
+        Unit::Resource::PaymentResource.create_bulk_payment(request)
+      end
+
+      # Create a batch release
+      # @see https://docs.unit.co/batch-payments/#create-batch-releases
+      # @param account_id [String]
+      # @param amount [Integer]
+      # @param description [String]
+      # @param sender_name [String]
+      # @param sender_address [Address]
+      # @param sender_account_number [String]
+      # @param tags [Hash] - optional
+      # @param idempotency_key [String] - optional
+      def create_batch_release(requests)
+        payload = BatchReleaseRequestBuilder.new
+        requests.each do |req|
+          payload.add_request(req[:account_id], req[:batch_account_id], req[:amount], req[:description], req[:sender_name], req[:sender_address], req[:sender_account_number], req[:tags], req[:idempotency_key])
+        end
+        Unit::Resource::PaymentResource.create_batch_release(payload.to_hash)
+      end
+     end
   end
 end

data/lib/unit/models/received_payment/list_payment_params.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Request to list ach received payments by calling Unit's API
+# @see https://docs.unit.co/received-ach#list-received-payments
+module Unit
+  module ReceivedPayment
+    class ListPaymentParams
+      attr_reader :limit, :offset, :account_id, :customer_id, :status,
+                  :include_completed, :tags, :sort, :include
+
+      # @param limit [Integer] - optional
+      # @param offset [Integer] - optional
+      # @param account_id [String] - optional
+      # @param customer_id [String] - optional
+      # @param status [Array<String>] - optional
+      # @param include_completed [Boolean] - optional
+      # @param tags [Hash] - optional
+      # @param sort [String] - optional
+      # @param include [Array<String>] - optional
+      def initialize(limit = RECEIVED_PAYMENT_LIMIT, offset = ACH_PAYMENT_OFFSET, account_id = nil, customer_id = nil, status = nil,
+                     include_completed = nil, tags = nil, sort = nil, include = nil)
+        @limit = limit
+        @offset = offset
+        @account_id = account_id
+        @customer_id = customer_id
+        @status = status
+        @include_completed = include_completed
+        @tags = tags
+        @sort = sort
+        @include = include
+      end
+
+      def to_hash
+        params = {
+          "page[limit]": limit,
+          "page[offset]": offset,
+          "filter[accountId]": account_id,
+          "filter[customerId]": customer_id,
+          "filter[includeCompleted]": include_completed,
+          "filter[tags]": tags,
+          "sort": sort,
+          "include": include&.join(",")
+        }
+        status&.each_with_index&.map do |val, index|
+          params.merge!({ "filter[status][#{index}]": val })
+        end
+        params.compact
+      end
+    end
+  end
+end

data/lib/unit/models/received_payment/patch_payment_request.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Request to update a received ACH payment
+# @see https://docs.unit.co/received-ach#update-received-payment
+module Unit
+  module ReceivedPayment
+    class PatchPaymentRequest
+      attr_reader :payment_id, :tags
+
+      # @param payment_id [String]
+      # @param tags [Hash] - optional
+      def initialize(payment_id, tags = nil)
+        @payment_id = payment_id
+        @tags = tags
+      end
+
+      def to_json_api
+        payload = {
+          "data": {
+            "type": "achReceivedPayment",
+            "attributes": {
+              tags: tags
+            }
+          }
+        }
+        payload[:data][:attributes].compact!
+        payload.to_json
+      end
+    end
+  end
+end

data/lib/unit/models/received_payment/received_payment.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Unit
+  module ReceivedPayment
+    RECEIVED_PAYMENT_LIMIT = 100
+    RECEIVED_PAYMENT_OFFSET = 0
+
+    autoload :PatchPaymentRequest, "unit/models/received_payment/patch_payment_request"
+    autoload :ListPaymentParams, "unit/models/received_payment/list_payment_params"
+
+    class << self
+      # Get received ach payment by calling Unit's API
+      # @see https://docs.unit.co/received-ach#get-specific-received-payment
+      # @param payment_id [String]
+      def get_payment(payment_id:)
+        Unit::Resource::ReceivedPaymentResource.get_payment(payment_id)
+      end
+
+      # Update a received ACH payment by calling Unit's API
+      # @see https://docs.unit.co/received-ach#update-received-payment
+      # @param payment_id [String]
+      # @param tags [Hash] - optional
+      def update_payment(payment_id:, tags: nil)
+        request = Unit::ReceivedPayment::PatchPaymentRequest.new(payment_id, tags)
+        Unit::Resource::ReceivedPaymentResource.update_payment(request)
+      end
+
+      # List ach payments by calling Unit's API
+      # @see https://docs.unit.co/received-ach#list-received-payments
+      # @param limit [Integer] - optional
+      # @param offset [Integer] - optional
+      # @param account_id [String] - optional
+      # @param customer_id [String] - optional
+      # @param status [Array<String>] - optional
+      # @param include_completed [Boolean] - optional
+      # @param tags [Hash] - optional
+      # @param sort [String] - optional
+      # @param include [Array<String>] - optional
+      def list_payments(limit: RECEIVED_PAYMENT_LIMIT, offset: RECEIVED_PAYMENT_OFFSET, account_id: nil, customer_id: nil, status: nil,
+                        include_completed: nil, tags: nil, sort: nil, include: nil)
+        request = Unit::ReceivedPayment::ListPaymentParams.new(limit, offset, account_id, customer_id, status,
+                                                               include_completed, tags, sort, include)
+        Unit::Resource::ReceivedPaymentResource.list_payments(request)
+      end
+
+      # Advance a received payment by calling Unit's API
+      # @see https://docs.unit.co/received-ach#advance-received-payment
+      # @param payment_id [String]
+      def advance_payment(payment_id:)
+        Unit::Resource::ReceivedPaymentResource.advance_payment(payment_id)
+      end
+    end
+  end
+end

data/lib/unit/models/recurring_payment/create_recurring_credit_ach_payment_request.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Request to create a recurring credit ach payment
+# @see https://docs.unit.co/recurring-payments/#recurring-payment-credit-ach-payment
+module Unit
+  module RecurringPayment
+    class CreateRecurringCreditAchPaymentRequest
+      attr_reader :account_id, :counterparty_id, :amount, :description, :addenda, :schedule, :idempotency_key, :tags
+
+      # @param account_id [String]
+      # @param counterparty_id [String]
+      # @param amount [Integer]
+      # @param description [String]
+      # @param schedule [CreateSchedule]
+      # @param addenda [String] - optional
+      # @param idempotency_key [String] - optional
+      # @param tags [Hash] - optional
+      def initialize(account_id, counterparty_id, amount, description, schedule, addenda = nil, idempotency_key = nil, tags = nil)
+        @account_id = account_id
+        @counterparty_id = counterparty_id
+        @amount = amount
+        @description = description
+        @addenda = addenda
+        @schedule = schedule
+        @idempotency_key = idempotency_key
+        @tags = tags
+      end
+
+      def to_json_api
+        payload = {
+          "data": {
+            "type": "recurringCreditAchPayment",
+            "attributes": {
+              "amount": amount,
+              "description": description,
+              "addenda": addenda,
+              "schedule": schedule&.represent,
+              "idempotencyKey": idempotency_key,
+              "tags": tags
+            },
+            "relationships": {
+              account: Unit::Types::Relationship.new("depositAccount", account_id).to_hash,
+              counterparty: Unit::Types::Relationship.new("counterparty", counterparty_id).to_hash
+            }
+          }
+        }
+        payload[:data][:attributes].compact!
+        payload.to_json
+      end
+    end
+  end
+end

data/lib/unit/models/recurring_payment/create_recurring_credit_book_payment_request.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Request to create a recurring credit book payment
+# @see https://docs.unit.co/recurring-payments/#recurring-credit-book-payment
+module Unit
+  module RecurringPayment
+    class CreateRecurringCreditBookPaymentRequest
+      attr_reader :account_id, :counterparty_id, :amount, :description, :schedule, :transaction_summary_override, :idempotency_key, :tags
+
+      # @param account_id [String]
+      # @param counterparty_id [String]
+      # @param amount [Integer]
+      # @param description [String]
+      # @param schedule [CreateSchedule]
+      # @param transaction_summary_override [String] - optional
+      # @param idempotency_key [String] - optional
+      # @param tags [Hash] - optional
+      def initialize(account_id, counterparty_id, amount, description, schedule,
+                     transaction_summary_override = nil, idempotency_key = nil, tags = nil)
+        @account_id = account_id
+        @counterparty_id = counterparty_id
+        @amount = amount
+        @description = description
+        @transaction_summary_override = transaction_summary_override
+        @schedule = schedule
+        @idempotency_key = idempotency_key
+        @tags = tags
+      end
+
+      def to_json_api
+        payload = {
+          "data": {
+            "type": "recurringCreditBookPayment",
+            "attributes": {
+              "amount": amount,
+              "description": description,
+              "schedule": schedule&.represent,
+              "transaction_summary_override": transaction_summary_override,
+              "idempotencyKey": idempotency_key,
+              "tags": tags
+            },
+            "relationships":
+              {
+                account: Unit::Types::Relationship.new("depositAccount", account_id).to_hash,
+                counterpartyAccount: Unit::Types::Relationship.new("depositAccount", counterparty_id).to_hash
+              }
+          }
+        }
+        payload[:data][:attributes].compact!
+        payload.to_json
+      end
+    end
+  end
+end