unit_ruby_sdk 1.0.2 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebccfab4c5a1935e6155ab1778b6c8beb123e7a4171b14ea6fcb2617d84d9da0
-  data.tar.gz: 195fe66d952a385323e750b19abca9940843645252771462efbefc75dc3a1e68
+  metadata.gz: 5b262e1336d0a6f1e2a6633172d3fe0fb030eb658e3a30ced02803e6f00bd22d
+  data.tar.gz: cbcb03bfba7390d4b27e5b1485d5f60c66fbc50104d4066764c482a3fd2ecb12
 SHA512:
-  metadata.gz: 92662a6367cb982b8fe77577b729e28139a9da4b78da5518ea99e32c064fbfede80106477569380a2b68c4816e1e2e4641b4911d38f63cd608ca8f9abb8c9dc4
-  data.tar.gz: a80e9f7bb02d93e24adafa4c0f1d792ad7fa9ee9bcf64a421c5d06a45366e90ed5a909fa68271ccd026c287ef2ecf4167cddf436563a6738d66a0042688602b7
+  metadata.gz: 35379395a2258233b3b9cff6cc239fde4aeee3ba43b7b423a6da5508e1b4ed2ca0aae735cad7d5bda0ef539816b761d44b1071f637f167010708704c37bb6fff
+  data.tar.gz: 291d0580135e0832bead828127eb3341f740d9cd4b9cb131349fcda06a7700dd02aae5b1cb179de9ac09eda3b347304566b370f19f7eaccfc002b2c1582f995e

data/README.md

@@ -62,6 +62,28 @@ upload_document_request = Unit::Application.upload_document(
 puts upload_document_request.data.id
 ```
 
+### Creating a deposit account request
+```ruby
+relationships = { "customer": Unit::Types::Relationship.new("customer", "111009").to_hash }
+response = Unit::Account::Deposit.create_deposit_account(
+  deposit_product: "checking", 
+  tags: { "purpose": "checking" }, 
+  relationships: relationships)
+deposit_account = response.data
+puts deposit_account.id
+```
+
+### Creating a credit account request
+```ruby
+response = Unit::Account::Credit.create_credit_account(
+  credit_terms: "credit_terms_test", 
+  credit_limit: 20_000, 
+  customer_id: "851228", 
+  tags: { "purpose": "tax" })
+credit_account = response.data
+puts credit_account.id
+```
+
 ### Fetching a Customer
 
 ```ruby
@@ -121,6 +143,44 @@ deposit = response.data
 puts deposit.id
 ```
 
+### Creating a counterparty with a plaid token
+```ruby
+response = Unit::Counterparty.create_with_plaid_token(
+  customer_id: "823139", 
+  type: "Business", 
+  name: "Jo Joel", 
+  plaid_processor_token: "processor-sandbox-plaid-token")
+
+counterparty = response.data
+puts counterparty.id
+```
+
+
+### Creating a Payment to linked counterparty
+```ruby
+ response = Unit::Payment.create_ach_payment_linked(
+   account_id: "123456", 
+   counterparty_id: "56784", 
+   amount: 1000, 
+   direction: "Credit",
+   description: "test payment"
+ )
+ ach_payment = response.data
+ puts ach_payment.id
+```
+
+### Creating a wire payment
+```ruby
+ address = Unit::Types::Address.new('123 Main St', 'San Francisco', 'CA', '94205', 'US')
+ response = Unit::Payment.create_wire_payment(
+   account_id: "1234", 
+   amount: 1000, 
+   description: "test payment", 
+   counterparty: Unit::Types::WireCounterparty.new("Jane Doe", "27573", "812345678", address))
+ wire_payment = response.data
+ puts wire_payment.id
+```
+
 ### Logging Errors
 
 ```ruby

data/lib/unit/api_resources/account_resource.rb

@@ -98,7 +98,7 @@ module Unit
         # @param params [BalanceHistoryRequest]
         # @return [UnitResponse, UnitError]
         def get_account_balance_history(params)
-          response = HttpHelper.get("#{api_url}/account-end-of-day", params: params.to_hash.to_json, headers: headers)
+          response = HttpHelper.get("#{api_url}/account-end-of-day", params: params.to_hash, headers: headers)
           response_handler(response)
         end
 

data/lib/unit/api_resources/counterparty_resource.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "./base_resource"
+require_relative "../utils/http_helper"
+require "json"
+
+# class for creating requests for counterparties to Unit API and parsing responses
+# @see https://docs.unit.co/payments-counterparties
+module Unit
+  module Resource
+    class CounterpartyResource < Unit::Resource::BaseResource
+      class << self
+        # Create a counterparty by calling Unit's API
+        # @param request [CreateCounterpartyRequest, CreateWithPlaidTokenRequest]
+        # @return [UnitResponse, UnitError]
+        def create_counterparty(request)
+          payload = request.to_json_api
+          response = HttpHelper.post("#{api_url}/counterparties", body: payload, headers: headers)
+          response_handler(response)
+        end
+
+        # Update counterparty by calling Unit's API
+        # @param request [UpdateCounterpartyRequest]
+        # @return [UnitResponse, UnitError]
+        def update_counterparty(request)
+          payload = request.to_json_api
+          response = HttpHelper.patch("#{api_url}/counterparties/#{request.counterparty_id}", body: payload, headers: headers)
+          response_handler(response)
+        end
+
+        # Delete counterparty by calling Unit's API
+        # @param counterparty_id String
+        # @return [UnitResponse, UnitError]
+        def delete(counterparty_id)
+          response = HttpHelper.delete("#{api_url}/counterparties/#{counterparty_id}", headers: headers, response_type: "delete")
+          file_response_handler(response)
+        end
+
+        # Get counterparty by id by calling Unit's API
+        # @param counterparty_id String
+        # @return [UnitResponse, UnitError]
+        def get_counterparty(counterparty_id)
+          response = HttpHelper.get("#{api_url}/counterparties/#{counterparty_id}", headers: headers)
+          response_handler(response)
+        end
+
+        # Get counterparty balance
+        # @param counterparty_id String
+        # @return [UnitResponse, UnitError]
+        def get_counterparty_balance(counterparty_id)
+          response = HttpHelper.get("#{api_url}/counterparties/#{counterparty_id}/balance", headers: headers)
+          response_handler(response)
+        end
+
+        # List counterparties
+        # @param params [ListCounterpartyParams]
+        # @return [UnitResponse, UnitError]
+        def list(params = nil)
+          response = HttpHelper.get("#{api_url}/counterparties", params: params.to_hash, headers: headers)
+          response_handler(response)
+        end
+      end
+    end
+  end
+end

data/lib/unit/api_resources/payment_resource.rb

@@ -3,14 +3,15 @@
 require_relative "./base_resource"
 require_relative "../utils/http_helper"
 
-# class for creating requests for book payments to Unit API and parsing responses
+# class for creating requests for payments to Unit API and parsing responses
 # @see https://docs.unit.co/book-payments#book-payments
+# @see https://docs.unit.co/ach-origination
 module Unit
   module Resource
     class PaymentResource < Unit::Resource::BaseResource
       class << self
-        # Create a new book payment by calling Unit's API
-        # @param request [CreatePaymentRequest]
+        # Create a new payment by calling Unit's API
+        # @param request [CreateAchPaymentInlineRequest, CreatePaymentLinkedRequest, CreateBookPaymentRequest, CreateWithPlaidTokenRequest, CreateWirePaymentRequest]
         # @return [UnitResponse, UnitError]
         def create_payment(request)
           payload = request.to_json_api
@@ -18,14 +19,32 @@ module Unit
           response_handler(response)
         end
 
-        # Update a book payment by calling Unit's API
-        # @param request [PatchBookPaymentRequest]
+        # Update a payment by calling Unit's API
+        # @param request [PatchBookPaymentRequest, PatchAchPaymentRequest]
         # @return [UnitResponse, UnitError]
         def update_payment(request)
           payload = request.to_json_api
           response = HttpHelper.patch("#{api_url}/payments/#{request.payment_id}", body: payload, headers: headers)
           response_handler(response)
         end
+
+        # Get a payment by calling Unit's API
+        # @param request [GetRequest]
+        # @return [UnitResponse, UnitError]
+        def get_payment(request)
+          payload = request.to_hash
+          response = HttpHelper.get("#{api_url}/payments/#{request.payment_id}", params: payload, headers: headers)
+          response_handler(response)
+        end
+
+        # List payments by calling Unit's API
+        # @param request [ListPaymentParams]
+        # @return [UnitResponse, UnitError]
+        def list_payments(request)
+          payload = request.to_hash
+          response = HttpHelper.get("#{api_url}/payments", params: payload, headers: headers)
+          response_handler(response)
+        end
       end
     end
   end

data/lib/unit/api_resources/transaction_resource.rb

@@ -34,6 +34,15 @@ module Unit
           response = HttpHelper.patch("#{api_url}/accounts/#{request.account_id}/transactions/#{request.transaction_id}", body: payload, headers: headers)
           response_handler(response)
         end
+
+        # Update a transaction by calling Unit's API
+        # @param request [PatchBookTransactionRequest, PatchChargeTransactionRequest]
+        # @return [UnitResponse, UnitError]
+        def update_transaction(request)
+          payload = request.to_json_api
+          response = HttpHelper.patch("#{api_url}/transactions/#{request.transaction_id}", body: payload, headers: headers)
+          response_handler(response)
+        end
       end
     end
   end

data/lib/unit/models/account/account.rb

@@ -34,8 +34,8 @@ module Unit
         # @param reason [String]
         # @param fraud_reason [String] - optional
         # @return [UnitResponse, UnitError]
-        def close_deposit_account(account_id:, reason:)
-          request = CloseDepositAccountRequest.new(account_id, reason)
+        def close_deposit_account(account_id:, reason:, fraud_reason: nil)
+          request = CloseDepositAccountRequest.new(account_id, reason, fraud_reason)
           Unit::Resource::AccountResource.close_account(request)
         end
 
@@ -153,5 +153,113 @@ module Unit
         end
       end
     end
+
+    module Credit
+      ACCOUNT_LIST_LIMIT = 100
+      ACCOUNT_LIST_OFFSET = 0
+      BALANCE_HISTORY_LIMIT = 100
+      BALANCE_HISTORY_OFFSET = 0
+      autoload :CreateAccountRequest, "unit/models/account/credit/create_account_request"
+      autoload :CloseAccountRequest, "unit/models/account/credit/close_account_request"
+      autoload :PatchAccountRequest, "unit/models/account/credit/patch_account_request"
+      autoload :BalanceHistoryRequest, "unit/models/account/credit/balance_history_request"
+      autoload :FreezeAccountRequest, "unit/models/account/credit/freeze_account_request"
+      autoload :ListAccountParams, "unit/models/account/credit/list_account_params"
+
+      class << self
+        # Create a credit account
+        # @see https://docs.unit.co/credit-accounts#create-credit-account
+        # @param credit_terms [String]
+        # @param credit_limit [Integer]
+        # @param customer_id [String] - optional
+        # @param tags [Hash] - optional
+        # @param idempotency_key [String] - optional
+        def create_credit_account(credit_terms:, credit_limit:, customer_id: nil, tags: nil, idempotency_key: nil)
+          request = CreateAccountRequest.new(credit_terms, credit_limit, customer_id, tags, idempotency_key)
+          Unit::Resource::AccountResource.create_account(request)
+        end
+
+        # Close a credit account
+        # @see https://docs.unit.co/credit-accounts#close-account
+        # @param account_id [String]
+        # @param reason [String]
+        # @param fraud_reason [String] - optional
+        def close_credit_account(account_id:, reason:, fraud_reason: nil)
+          request = CloseAccountRequest.new(account_id, reason, fraud_reason)
+          Unit::Resource::AccountResource.close_account(request)
+        end
+
+        # Get a credit account by id
+        # @see https://docs.unit.co/credit-accounts#get-specific-credit-account
+        # @param account_id [String]
+        def get_credit_account(account_id:)
+          Unit::Resource::AccountResource.get_account(account_id)
+        end
+
+        # Freeze credit account
+        # @see https://docs.unit.co/credit-accounts#freeze-account
+        # @param account_id [String]
+        # @param reason [String]
+        # @param reason_text [String] - optional
+        def freeze_credit_account(account_id:, reason:, reason_text: nil)
+          request = FreezeAccountRequest.new(account_id, reason, reason_text)
+          Unit::Resource::AccountResource.freeze_account(request)
+        end
+
+        # Unfreeze credit account
+        # @see https://docs.unit.co/credit-accounts#unfreeze-account
+        # @param account_id [String]
+        def unfreeze_credit_account(account_id:)
+          Unit::Resource::AccountResource.unfreeze_account(account_id)
+        end
+
+        # List credit accounts by calling Unit's API
+        # @see https://docs.unit.co/credit-accounts#list-credit-accounts
+        # @param limit [Integer] - optional
+        # @param offset [Integer] - optional
+        # @param customer_id [String] - optional
+        # @param tags [Hash] - optional
+        # @param status [Array<String>] - optional
+        # @param from_balance [Integer] - optional
+        # @param to_balance [Integer] - optional
+        # @param include [Array] - optional
+        # @param type [String] - optional
+        def list_credit_accounts(limit: ACCOUNT_LIST_LIMIT, offset: ACCOUNT_LIST_OFFSET, customer_id: nil, tags: nil,
+                                 status: nil, from_balance: nil, to_balance: nil, include: nil, type: nil)
+          request = ListAccountParams.new(limit, offset, customer_id, tags, status, from_balance, to_balance, include, type)
+          Unit::Resource::AccountResource.list_accounts(request)
+        end
+
+        # Update a credit account by calling Unit's API
+        # @see https://docs.unit.co/credit-accounts#update-accounts
+        # @param tags [Hash] - optional
+        # @param credit_limit [Integer] - optional
+        def update_credit_account(account_id:, tags: nil, credit_limit: nil)
+          request = PatchAccountRequest.new(account_id, tags, credit_limit)
+          Unit::Resource::AccountResource.update_account(request)
+        end
+
+        # Limit a credit account
+        # @see https://docs.unit.co/credit-accounts#account-limits
+        # @param account_id [String]
+        def limits(account_id:)
+          Unit::Resource::AccountResource.limits(account_id)
+        end
+
+        # Get account balance history by calling Unit's API
+        # @see https://docs.unit.co/credit-accounts#get-account-balance-history
+        # @param limit [Integer] - optional
+        # @param offset [Integer] - optional
+        # @param account_id [String] - optional
+        # @param customer_id [String] - optional
+        # @param since [String] - optional
+        # @param _until [String] - optional
+        def get_balance_history(limit = BALANCE_HISTORY_LIMIT, offset = BALANCE_HISTORY_OFFSET, account_id: nil, customer_id: nil,
+                                since: nil, _until: nil)
+          request = BalanceHistoryRequest.new(limit, offset, account_id, customer_id, since, _until)
+          Unit::Resource::AccountResource.get_account_balance_history(request)
+        end
+      end
+    end
   end
 end

data/lib/unit/models/account/credit/balance_history_request.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Request to get the balance history of a credit account
+# @see https://docs.unit.co/credit-accounts/#get-account-balance-history
+module Unit
+  module Account
+    module Credit
+      class BalanceHistoryRequest
+        attr_reader :limit, :offset, :account_id, :customer_id, :since, :_until
+
+        # @param limit [Integer] - optional
+        # @param offset [Integer] - optional
+        # @param account_id [String] - optional
+        # @param customer_id [String] - optional
+        # @param since [String] - optional
+        # @param _until [String] - optional
+        def initialize(limit = BALANCE_HISTORY_LIMIT, offset = BALANCE_HISTORY_OFFSET, account_id = nil, customer_id = nil,
+                       since = nil, _until = nil)
+          @limit = limit
+          @offset = offset
+          @account_id = account_id
+          @customer_id = customer_id
+          @since = since
+          @_until = _until
+        end
+
+        def to_hash
+          params = { "page[limit]": limit,
+                     "page[offset]": offset,
+                     "filter[accountId]": account_id,
+                     "filter[customerId]": customer_id,
+                     "filter[since]": since,
+                     "filter[until]": _until }
+          params.compact
+        end
+      end
+    end
+  end
+end

data/lib/unit/models/account/credit/close_account_request.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Request to close a credit account
+# @see https://docs.unit.co/credit-accounts/#close-account
+module Unit
+  module Account
+    module Credit
+      class CloseAccountRequest
+        attr_reader :account_id, :reason, :fraud_reason
+
+        # @param account_id [String]
+        # @param reason [String]
+        # @param fraud_reason [String] - optional
+        def initialize(account_id, reason, fraud_reason = nil)
+          @account_id = account_id
+          @reason = reason
+          @fraud_reason = fraud_reason
+        end
+
+        def to_json_api
+          payload = {
+            data: {
+              type: "creditAccountClose",
+              attributes: {
+                reason: reason,
+                fraudReason: fraud_reason
+              }
+            }
+          }
+          payload[:data][:attributes].compact!
+          payload.to_json
+        end
+      end
+    end
+  end
+end

data/lib/unit/models/account/credit/create_account_request.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Request to create a deposit account
+# @see https://docs.unit.co/credit-accounts#create-credit-account
+module Unit
+  module Account
+    module Credit
+      class CreateAccountRequest
+        attr_reader :credit_terms, :credit_limit, :customer_id, :tags, :idempotency_key
+
+        # @param credit_terms [String]
+        # @param credit_limit [Integer]
+        # @param customer_id [String] - optional
+        # @param tags [Hash] - optional
+        # @param idempotency_key [String] - optional
+        def initialize(credit_terms, credit_limit, customer_id = nil, tags = nil, idempotency_key = nil)
+          @credit_terms = credit_terms
+          @credit_limit = credit_limit
+          @customer_id = customer_id
+          @tags = tags
+          @idempotency_key = idempotency_key
+        end
+
+        def to_json_api
+          payload = {
+            data: {
+              type: "creditAccount",
+              attributes: {
+                creditTerms: credit_terms,
+                creditLimit: credit_limit,
+                tags: tags
+              },
+              relationships: {
+                customer: Unit::Types::Relationship.new("customer", customer_id).to_hash
+              }
+            }
+          }
+          payload[:data][:attributes].compact!
+          payload.to_json
+        end
+      end
+    end
+  end
+end

data/lib/unit/models/account/credit/freeze_account_request.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Request to freeze a credit account
+# @see https://docs.unit.co/credit-accounts#freeze-account
+module Unit
+  module Account
+    module Credit
+      class FreezeAccountRequest
+        attr_reader :account_id, :reason, :reason_text
+
+        # @param account_id [String]
+        # @param reason [String]
+        # @param reason_text [String] - optional
+        def initialize(account_id, reason, reason_text = nil)
+          @account_id = account_id
+          @reason = reason
+          @reason_text = reason_text
+        end
+
+        def to_json_api
+          payload = {
+            data: {
+              type: "creditAccountFreeze",
+              attributes: {
+                reason: reason,
+                reasonText: reason_text
+              }
+            }
+          }
+          payload[:data][:attributes].compact!
+          payload.to_json
+        end
+      end
+    end
+  end
+end

data/lib/unit/models/account/credit/list_account_params.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# params for listing credit accounts
+# @see https://docs.unit.co/credit-accounts/#list-credit-accounts
+module Unit
+  module Account
+    module Credit
+      class ListAccountParams
+        attr_reader :limit, :offset, :customer_id, :tags, :status,
+                    :from_balance, :to_balance, :include, :type
+
+        # @param limit [Integer] - optional
+        # @param offset [Integer] - optional
+        # @param customer_id [String] - optional
+        # @param tags [Hash] - optional
+        # @param status [Array<String>] - optional
+        # @param from_balance [Integer] - optional
+        # @param to_balance [Integer] - optional
+        # @param include [Array] - optional
+        # @param type [String] - optional
+        def initialize(limit = ACCOUNT_LIST_LIMIT, offset = ACCOUNT_LIST_OFFSET, customer_id = nil, tags = nil,
+                       status = nil, from_balance = nil, to_balance = nil, include = nil, type = nil)
+          @limit = limit
+          @offset = offset
+          @customer_id = customer_id
+          @tags = tags
+          @status = status
+          @from_balance = from_balance
+          @to_balance = to_balance
+          @include = include
+          @type = type
+        end
+
+        def to_hash
+          params = { "page[limit]": limit,
+                     "page[offset]": offset,
+                     "filter[customerId]": customer_id,
+                     "filter[tags]": tags,
+                     "filter[fromBalance]": from_balance,
+                     "filter[toBalance]": to_balance,
+                     "filter[type]": type,
+                     "include": include&.join(",") }
+          status&.each_with_index&.map do |val, index|
+            params.merge!({ "filter[status][#{index}]": val })
+          end
+          params.compact
+        end
+      end
+    end
+  end
+end

data/lib/unit/models/account/credit/patch_account_request.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Request to update a credit account
+# @see https://docs.unit.co/credit-accounts#update-accounts
+module Unit
+  module Account
+    module Credit
+      class PatchAccountRequest
+        attr_reader :account_id, :tags, :credit_limit
+
+        # @param account_id [String]
+        # @param tags [Hash] - optional
+        # @param credit_limit [Integer] - optional
+        def initialize(account_id, tags = nil, credit_limit = nil)
+          @account_id = account_id
+          @tags = tags
+          @credit_limit = credit_limit
+        end
+
+        def to_json_api
+          payload = {
+            data: {
+              type: "creditAccount",
+              attributes: {
+                tags: tags,
+                creditLimit: credit_limit
+              }
+            }
+          }
+          payload[:data][:attributes].compact!
+          payload.to_json
+        end
+      end
+    end
+  end
+end