unit_ruby_sdk 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d20a17ad0586962f7984a43e052bbe2f8a1637adf318b91cbb35c2bd65268efe
-  data.tar.gz: 113eeaae42a13b4d89d31b870c935fc36d6221c4a09c3e4e8770c19e6b96a724
+  metadata.gz: 6886c703f37b77fbd4ccc6e174cf0c79b83c588c53f0cfaaa6a1503598fc1fbd
+  data.tar.gz: 0371acc6dc064fb9bf8969d10839cbe915e23772bb088493bf889abfeee50244
 SHA512:
-  metadata.gz: '0178fda07e7f4f9b3011c8e5b1dfa7a5fc4efffdc9d77b50bfabdab34c174293a2ca4cc90b77cb521646bba08d34b52732509c1652f96f3eab8bd0d38e573976'
-  data.tar.gz: 8a2b410f41503b00a1cd23637e8f332d96b4116e7a06d980894adff0f8e5ebf9343652629b6177e1890077805b88bcaded6e5dd525590671bacbae77870dc5ab
+  metadata.gz: 11d43e7bdaa9d8af5b2f3ac73823576773a784e9bf098d6fb232c08cbb5d76ac7de441da062ed33645c7804c2f19a897a4f0e8cdc1309f6b2b146c249c8edd0c
+  data.tar.gz: b8077c7600d42b3396a2f0b5437edde30b1e3d09899df5e0d5ebec0761822a3a8bbcd3b83cc9706245f3a02c26d3b4e0c0481ef19410874eed952292584464c7

data/README.md

@@ -14,7 +14,7 @@ gem install unit_ruby_sdk
 
 ## Usage
 
- Bellow are a few exapmles of the Ruby SDK application. For full documentation of the Unit API please refer to the full documentation at https://docs.unit.co/
+Bellow are a few usage examples of Unit's Ruby SDK. For full documentation of Unit's API please refer to the full documentation at https://docs.unit.co/
 
 ### Creating a Business Application
 
@@ -40,13 +40,13 @@ response = Unit::Application.create_business_application(
   industry: "Retail",
   contact: Unit::Types::BusinessContact.new(full_name, email, phone),
   officer: Unit::Types::Officer.new(full_name, date_of_birth, address, phone, email, ssn),
-  beneficial_owners: [beneficial_owner, beneficial_owner],
+  beneficial_owners: [beneficial_owner],
   entity_type: 'LLC'
 )
 
 application = response.data
 
-puts application.id
+puts application["id"]
 
 file = File.open("./spec/test.pdf", "rb")
 contents = file.read
@@ -59,7 +59,42 @@ upload_document_request = Unit::Application.upload_document(
   file_type: Unit::Types::DocumentFileType::PDF, 
   is_back_side: true)
 
-puts upload_document_request.data.id
+puts upload_document_request.data["id"]
+```
+
+### Creating a trust application
+
+```ruby
+full_name = Unit::Types::FullName.new('John', 'Doe')
+date_of_birth = '1980-08-10'
+address = Unit::Types::Address.new('123 Main St', 'San Francisco', 'CA', '94205', 'US')
+phone = Unit::Types::Phone.new('380', '555123222')
+email = 'jone.doe@unit-finance.com'
+ssn = '123456789'
+trust_contact = Unit::Types::TrustContact.new(full_name, email, phone, address)
+beneficiaries =  [Unit::Types::Beneficiary.new(full_name, date_of_birth).represent]
+grantor =  Unit::Types::Grantor.new(full_name, ssn, email, phone, address, date_of_birth)
+trustees = [Unit::Types::Trustee.new(full_name, ssn, email, phone, address, date_of_birth).represent]
+
+
+response = Unit::Application.create_trust_application(
+        name: "Trust me Inc.",
+        state_of_incorporation: "CA",
+        revocability: "Revocable",
+        source_of_funds: "Salary",
+        tax_id: "123456789",
+        grantor: grantor,
+        trustees: trustees,
+        beneficiaries: beneficiaries,
+        contact: trust_contact,
+        ip: "127.0.0.2",
+        tags: {
+          "userId": "106a75e9-de77-4e25-9561-faffe59d7814"
+        },
+        idempotency_key: "3a1a33be-4e12-4603-9ed0-820922389fb8")
+
+trust_application = response.data
+puts trust_application["id"]
 ```
 
 ### Creating a deposit account request
@@ -70,7 +105,7 @@ response = Unit::Account::Deposit.create_deposit_account(
   tags: { "purpose": "checking" }, 
   relationships: relationships)
 deposit_account = response.data
-puts deposit_account.id
+puts deposit_account["id"]
 ```
 
 ### Creating a credit account request
@@ -81,9 +116,22 @@ response = Unit::Account::Credit.create_credit_account(
   customer_id: "851228", 
   tags: { "purpose": "tax" })
 credit_account = response.data
-puts credit_account.id
+puts credit_account["id"]
+```
+
+### Creating a batch release request
+```ruby
+requests =
+  [
+    { account_id: "49230", batch_account_id: "1296383", amount: 100, description: "Description 1", sender_name: "Sender Name 1", sender_address: ADDRESS, sender_account_number: "1234" },
+    { account_id: "49230", batch_account_id: "1296383", amount: 100, description: "Description 1", sender_name: "Sender Name 1", sender_address: ADDRESS, sender_account_number: "12324" }
+  ]
+response = Unit::Payment.create_batch_release(requests)
+batch_release = response.data
+puts batch_release[0].id
 ```
 
+
 ### Fetching a Customer
 
 ```ruby
@@ -91,11 +139,10 @@ require 'unit_ruby_sdk'
 
 Unit.config(api_url: ENV['API_URL'], token: ENV['TOKEN'])
 
-customer = Unit::Customer.list_customers.first
-puts customer.id
+customer = Unit::Customer.list_customers(limit: 20, offset: 10).data.first
+puts customer["id"]
 ```
 
-### 
 ### Creating a Payment
     
 ```ruby
@@ -108,7 +155,7 @@ response = Unit::Payment.create_book_payment(
   counterparty_account_id: "36981"
 )
 payment = response.data
-puts payment.id
+puts payment["id"]
 ```
 
 ### Get a transaction by id
@@ -116,9 +163,21 @@ puts payment.id
 ```ruby
 response = Unit::Transaction.get_transaction(transaction_id: '12345', account_id: '72345')
 transaction = response.data
-puts transaction.id
+puts transaction["id"]
 ```
 
+### Get an authorization by id
+
+```ruby
+response = Unit::Authorization.get_authorization(
+  authorization_id: '12345',
+  include_non_authorized: true
+)
+authorization = response.data
+puts authorization.id
+```
+
+
 ### Creating an individual debit card
 ```ruby
 response = Unit::Card.create_individual_debit_card(
@@ -126,10 +185,38 @@ response = Unit::Card.create_individual_debit_card(
   type: "depositAccount",
   shipping_address: address,
   design: "default",
-  additional_embossed_text: "Second Cardholder"
+  additional_embossed_text: "Second Cardholder",
+  expiry_date: "03/27"
 )
 card = response.data
-puts card.id
+puts card["id"]
+```
+
+### Updating a received payment
+```ruby
+response = Unit::ReceivedPayment.update_payment(
+  payment_id: "1232", 
+  tags: { purpose: "test" })
+received_payment = response.data
+puts received_payment["id"]
+
+### Creating a business credit card
+```ruby
+full_name = Unit::Types::FullName.new('John', 'Doe')
+date_of_birth = '1980-08-10'
+address = Unit::Types::Address.new('123 Main St', 'San Francisco', 'CA', '94205', 'US')
+phone = Unit::Types::Phone.new('380', '555123222')
+email = 'jone.doe@unit-finance.com'
+response = Unit::Card.create_business_credit_card(
+  account_id: "1234", 
+  full_name: full_name,
+  date_of_birth: date_of_birth, 
+  address: address, 
+  phone: phone, 
+  email: email
+)
+charge_card = response.data
+puts charge_card.id
 ```
 
 ### Creating a check deposit
@@ -140,7 +227,7 @@ response = Unit::CheckDeposit.create_deposit(
   description: "test check deposit"
 )
 deposit = response.data
-puts deposit.id
+puts deposit["id"]
 ```
 
 ### Creating a counterparty with a plaid token
@@ -152,7 +239,7 @@ response = Unit::Counterparty.create_with_plaid_token(
   plaid_processor_token: "processor-sandbox-plaid-token")
 
 counterparty = response.data
-puts counterparty.id
+puts counterparty["id"]
 ```
 
 
@@ -166,9 +253,19 @@ puts counterparty.id
    description: "test payment"
  )
  ach_payment = response.data
- puts ach_payment.id
+ puts ach_payment["id"]
 ```
 
+### Creating a recurring payment
+```ruby
+ schedule = Unit::Types::CreateSchedule.new("Monthly", 3)
+ response = Unit::RecurringPayment.create_recurring_credit_book_payment(account_id: "27573", counterparty_id: "36099", amount: 1000, 
+                                                                        description: "test payme", schedule: schedule)
+ recurring_payment = response.data
+ puts recurring_payment.id
+```
+
+
 ### Creating a wire payment
 ```ruby
  address = Unit::Types::Address.new('123 Main St', 'San Francisco', 'CA', '94205', 'US')
@@ -178,7 +275,14 @@ puts counterparty.id
    description: "test payment", 
    counterparty: Unit::Types::WireCounterparty.new("Jane Doe", "27573", "812345678", address))
  wire_payment = response.data
- puts wire_payment.id
+ puts wire_payment["id"]
+```
+
+### Get an event by id
+```ruby
+response = Unit::Event.get_event(event_id: "12605774")
+event = response.data
+puts event.id
 ```
 
 ### Creating a bulk payment
@@ -195,10 +299,56 @@ ach_payment_plaid_token_request = Unit::Payment::CreateWithPlaidTokenRequest.new
 response = Unit::Payment.create_bulk_payment(
   requests: [book_payment_request, wire_payment_request, ach_payment_inline_request, ach_payment_linked_request, ach_payment_plaid_token_request])
 bulk_payment = response.data
-puts bulk_payment.id
+puts bulk_payment["id"]
+```
+
+### Creating a book repayment
+```ruby
+response = Unit::Repayment.create_book_repayment(
+  account_id: "10001",
+  credit_account_id: "10002",
+  counterparty_account_id: "10003", 
+  description: "test", amount: 100,
+  transaction_summary_override: "override", 
+  tags: { purpose: "test" }, 
+  idempotency_key: "3a1a33be-4e12-4603-9ed0-820922389fb8")
+book_repayment = response.data
+puts book_repayment.id
 ```
+
 ### Logging Errors
 
+### Handling Response
+
+### Creating a webhook
+```ruby
+response = Unit::Webhook.create_webhook(
+  label: "some label", 
+  url: "https://webhook.site/81ee6b53-fde4-4b7d-85a0-0b6249a4488d",
+  token: "MyToken", 
+  content_type: "Json", 
+  delivery_mode: "AtLeastOnce",
+  include_resources: false,
+  subscription_type: "OnlyAuthorizationRequest")
+webhook = response.data
+puts webhook["id"]
+```
+
+### Creating a fee
+```ruby
+response = Unit::Fee.create_fee(
+  account_id: "27573", 
+  amount: 12_345, 
+  description: "test", 
+  tags: { purpose: "test" }, 
+  idempotency_key: "123"
+)
+fee = response.data
+puts fee["id"]
+```
+
+
+### Handling Response
 ```ruby
 require 'unit_ruby_sdk'
 
@@ -207,6 +357,11 @@ Unit.config(api_url: ENV['API_URL'], token: "missing token")
 # response is a Unit::UnitError
 response = Unit::Application.get_application('123')
 
-# Prints "Bearer token is missing"
-response.errors.each{|error| puts error.title}
+# Checks the response to be an instance of UnitResponse
+if response.instance_of?(Unit::UnitResponse)
+  # handle response
+else
+  # handle error
+  response.errors.each{|error| puts error.title}
+end
 ```

data/lib/unit/api_resources/application_form_resource.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "./base_resource"
+require_relative "../utils/http_helper"
+require "json"
+
+# class for creating requests for application forms to Unit API and parsing responses
+# @see https://docs.unit.co/application-forms
+module Unit
+  module Resource
+    class ApplicationFormResource < Unit::Resource::BaseResource
+      class << self
+        # Create a new application form by calling Unit's API
+        # @param request [CreateApplicationFormRequest] request
+        # @return [UnitResponse, UnitError]
+        def create_application_form(request)
+          payload = request.to_json_api
+          response = HttpHelper.post("#{api_url}/application-forms", body: payload, headers: headers)
+          response_handler(response)
+        end
+
+        # Get application form by calling Unit's API
+        # @param application_form_id [String]
+        # @return [UnitResponse, UnitError]
+        def get_application_form(application_form_id)
+          response = HttpHelper.get("#{api_url}/application-forms/#{application_form_id}", headers: headers)
+          response_handler(response)
+        end
+
+        # List application forms by calling Unit's API
+        # @param params [ListApplicationFormParams]
+        # @return [UnitResponse, UnitError]
+        def list_application_forms(params = nil)
+          response = HttpHelper.get("#{api_url}/application-forms", headers: headers, params: params.to_hash)
+          response_handler(response)
+        end
+      end
+    end
+  end
+end

data/lib/unit/api_resources/authorization_request_resource.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "./base_resource"
+require_relative "../utils/http_helper"
+
+# class for creating cards authorization requests
+# @see https://docs.unit.co/cards-authorization-requests
+
+module Unit
+  module Resource
+    class AuthorizationRequestResource < Unit::Resource::BaseResource
+      class << self
+        # Get authorization request by calling Unit's API
+        # @param request_id [String]
+        # @return [UnitResponse, UnitError]
+        def get_authorization_request(request_id)
+          response = HttpHelper.get("#{api_url}/authorization-requests/#{request_id}", headers: headers)
+          response_handler(response)
+        end
+
+        # List authorization requests by calling Unit's API
+        # @param params [ListAuthorizationParams]
+        # @return [UnitResponse, UnitError]
+        def list(params = nil)
+          response = HttpHelper.get("#{api_url}/authorization-requests", params: params.to_hash, headers: headers)
+          response_handler(response)
+        end
+
+        # Approve an authorization request by calling Unit's API
+        # @param request [ApproveRequest]
+        # @return [UnitResponse, UnitError]
+        def approve(request)
+          payload = request.to_json_api
+          response = HttpHelper.post("#{api_url}/authorization-requests/#{request.authorization_request_id}/approve", body: payload, headers: headers)
+          response_handler(response)
+        end
+
+        # Decline an authorization request by calling Unit's API
+        # @param request [DeclineRequest]
+        # @return [UnitResponse, UnitError]
+        def decline(request)
+          payload = request.to_json_api
+          response = HttpHelper.post("#{api_url}/authorization-requests/#{request.authorization_request_id}/decline", body: payload, headers: headers)
+          response_handler(response)
+        end
+      end
+    end
+  end
+end

data/lib/unit/api_resources/authorization_resource.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "./base_resource"
+require_relative "../utils/http_helper"
+require "json"
+# class for creating requests for authorizations to Unit API and parsing responses
+# @see https://docs.unit.co/cards-authorizations
+module Unit
+  module Resource
+    class AuthorizationResource < Unit::Resource::BaseResource
+      class << self
+        # Get authorization by calling Unit's API
+        # @param params [GetRequest]
+        # @return [UnitResponse, UnitError]
+        def get(params)
+          payload = params.to_hash
+          response = HttpHelper.get("#{api_url}/authorizations/#{params.authorization_id}", params: payload, headers: headers)
+          response_handler(response)
+        end
+
+        # Get authorization by calling Unit's API
+        # @param params [GetRequest]
+        # @return [UnitResponse, UnitError]
+        def list(params = nil)
+          response = HttpHelper.get("#{api_url}/authorizations", params: params&.to_hash, headers: headers)
+          response_handler(response)
+        end
+      end
+    end
+  end
+end

data/lib/unit/api_resources/card_resource.rb

@@ -83,6 +83,14 @@ module Unit
           response_handler(response)
         end
 
+        # Update card by calling Unit's API
+        # @param request [PatchBusinessCardRequest, PatchBusinessCreditCardRequest, PatchBusinessVirtualCardRequest, PatchBusinessVirtualCreditCardRequest]
+        def update(request)
+          payload = request.to_json_api
+          response = HttpHelper.patch("#{api_url}/cards/#{request.card_id}", headers: headers, body: payload)
+          response_handler(response)
+        end
+
         # List cards by calling Unit's API
         # @param params [ListCardParams]
         # @return [UnitResponse, UnitError]

data/lib/unit/api_resources/event_resource.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../api_resources/base_resource"
+require_relative "../models/unit_response"
+require_relative "../errors/unit_error"
+require_relative "../utils/http_helper"
+
+# class for creating requests for events to Unit API and parsing responses
+# @see https://docs.unit.co/events
+module Unit
+  module Resource
+    class EventResource < Unit::Resource::BaseResource
+      class << self
+        # Get an event by id by calling Unit's API
+        # @param event_id [String]
+        # @return [UnitResponse, UnitError]
+        def get(event_id)
+          response = HttpHelper.get("#{api_url}/events/#{event_id}", headers: headers)
+          response_handler(response)
+        end
+
+        # List events by calling Unit's API
+        # @param params [ListEventParams]
+        # @return [UnitResponse, UnitError]
+        def list(params = nil)
+          response = HttpHelper.get("#{api_url}/events", params: params&.to_hash, headers: headers)
+          response_handler(response)
+        end
+
+        # Fire an event by calling Unit's API
+        # @param event_id [String]
+        # @return [UnitResponse, UnitError]
+        def fire(event_id)
+          response = HttpHelper.post("#{api_url}/events/#{event_id}", headers: headers)
+          response_handler(response)
+        end
+      end
+    end
+  end
+end

data/lib/unit/api_resources/fee_resource.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "./base_resource"
+require_relative "../utils/http_helper"
+
+# class for creating requests for fees to Unit API and parsing responses
+# @see https://docs.unit.co/fees/
+module Unit
+  module Resource
+    class FeeResource < Unit::Resource::BaseResource
+      class << self
+        # Create a new fee by calling Unit's API
+        # @param request [CreateFeeRequest]
+        # @return [UnitResponse, UnitError]
+        def create_fee(request)
+          payload = request.to_json_api
+          response = HttpHelper.post("#{api_url}/fees", body: payload, headers: headers)
+          response_handler(response)
+        end
+
+        # Reverse a fee by calling Unit's API
+        # @param request [ReverseFeeRequest]
+        # @return [UnitResponse, UnitError]
+        def reverse_fee(request)
+          payload = request.to_json_api
+          response = HttpHelper.post("#{api_url}/fees/reverse", body: payload, headers: headers)
+          response_handler(response)
+        end
+      end
+    end
+  end
+end

data/lib/unit/api_resources/payment_resource.rb

@@ -53,6 +53,15 @@ module Unit
           response = HttpHelper.get("#{api_url}/payments", params: payload, headers: headers)
           response_handler(response)
         end
+
+        # Create a new batch release by calling Unit's API
+        # @param request [BatchReleaseRequestBuilder]
+        # @return [UnitResponse, UnitError]
+        def create_batch_release(request)
+          payload = request.to_hash.to_json
+          response = HttpHelper.post("#{api_url}/batch-releases", body: payload, headers: headers)
+          response_handler(response)
+        end
       end
     end
   end

data/lib/unit/api_resources/received_payment_resource.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "./base_resource"
+require_relative "../utils/http_helper"
+
+# class for creating requests for book payments to Unit API and parsing responses
+# @see https://docs.unit.co/book-payments#book-payments
+module Unit
+  module Resource
+    class ReceivedPaymentResource < Unit::Resource::BaseResource
+      class << self
+        # Get a received ach payment by calling Unit's API
+        # @param payment_id [String]
+        # @return [UnitResponse, UnitError]
+        def get_payment(payment_id)
+          response = HttpHelper.get("#{api_url}/received-payments/#{payment_id}", headers: headers)
+          response_handler(response)
+        end
+
+        # List received ach payments by calling Unit's API
+        # @param params [ListAchPaymentParams]
+        # @return [UnitResponse, UnitError]
+        def list_payments(params = nil)
+          response = HttpHelper.get("#{api_url}/received-payments", params: params&.to_hash, headers: headers)
+          response_handler(response)
+        end
+
+        # Update a received ach payment by calling Unit's API
+        # @param request [PatchReceivedPaymentRequest]
+        # @return [UnitResponse, UnitError]
+        def update_payment(request)
+          payload = request.to_json_api
+          response = HttpHelper.patch("#{api_url}/received-payments/#{request.payment_id}", body: payload, headers: headers)
+          response_handler(response)
+        end
+
+        # Advance an ach payment by calling Unit's API
+        # @param payment_id [String]
+        # @return [UnitResponse, UnitError]
+        def advance_received_payment(payment_id)
+          response = HttpHelper.post("#{api_url}/received-payments/#{payment_id}/advance", headers: headers)
+          response_handler(response)
+        end
+      end
+    end
+  end
+end

data/lib/unit/api_resources/recurring_payment_resource.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "./base_resource"
+require_relative "../utils/http_helper"
+
+# class for creating requests for payments to Unit API and parsing responses
+# @see https://docs.unit.co/recurring-payments
+module Unit
+  module Resource
+    class RecurringPaymentResource < Unit::Resource::BaseResource
+      class << self
+        # Create a new recurring payment by calling Unit's API
+        # @param request [CreateRecurringCreditAchPaymentRequest, CreateRecurringDebitAchPaymentRequest, CreateRecurringCreditBookPaymentRequest]
+        # @return [UnitResponse, UnitError]
+        def create_recurring_payment(request)
+          payload = request.to_json_api
+          response = HttpHelper.post("#{api_url}/recurring-payments", body: payload, headers: headers)
+          response_handler(response)
+        end
+
+        # Disable a new recurring payment by calling Unit's API
+        # @param recurring_payment_id [String]
+        # @return [UnitResponse, UnitError]
+        def disable_recurring_payment(recurring_payment_id)
+          response = HttpHelper.post("#{api_url}/recurring-payments/#{recurring_payment_id}/disable", headers: headers)
+          response_handler(response)
+        end
+
+        # Enable a new recurring payment by calling Unit's API
+        # @param recurring_payment_id [String]
+        # @return [UnitResponse, UnitError]
+        def enable_recurring_payment(recurring_payment_id)
+          response = HttpHelper.post("#{api_url}/recurring-payments/#{recurring_payment_id}/enable", headers: headers)
+          response_handler(response)
+        end
+
+        # List a new recurring payment by calling Unit's API
+        # @param request [ListRecurringPaymentParams]
+        # @return [UnitResponse, UnitError]
+        def list_recurring_payment(params = {})
+          response = HttpHelper.get("#{api_url}/recurring-payments", params: params.to_hash, headers: headers)
+          response_handler(response)
+        end
+
+        # Get a new recurring payment by calling Unit's API
+        # @param recurring_payment_id [String]
+        # @return [UnitResponse, UnitError]
+        def get_recurring_payment(recurring_payment_id)
+          response = HttpHelper.get("#{api_url}/recurring-payments/#{recurring_payment_id}", headers: headers)
+          response_handler(response)
+        end
+      end
+    end
+  end
+end