unit_ruby_sdk 1.0.2 → 1.0.4

data/lib/unit/models/counterparty/counterparty.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Unit
+  module Counterparty
+    COUNTER_PARTY_LIMIT = 100
+    COUNTER_PARTY_OFFSET = 0
+
+    autoload :CreateCounterpartyRequest, "unit/models/counterparty/create_counterparty_request"
+    autoload :CreateWithPlaidTokenRequest, "unit/models/counterparty/create_with_plaid_token_request"
+    autoload :ListCounterpartyParams, "unit/models/counterparty/list_counterparty_params"
+    autoload :UpdateCounterpartyRequest, "unit/models/counterparty/update_counterparty_request"
+
+    class << self
+      # Create counterparty by calling Unit's API
+      # @see https://docs.unit.co/payments-counterparties/#create-counterparty
+      # @param customer_id [String]
+      # @param name [String]
+      # @param routing_number [String]
+      # @param account_number [String]
+      # @param account_type [String]
+      # @param type [String]
+      # @param tags [Hash] - optional
+      # @param permissions [String] - optional
+      # @param idempotency_key [String] - optional
+      def create_counterparty(customer_id:, name:, routing_number:, account_number:, account_type:, type:, tags: nil, permissions: nil, idempotency_key: nil)
+        request = CreateCounterpartyRequest.new(customer_id, name, routing_number, account_number, account_type, type, tags, permissions, idempotency_key)
+        Unit::Resource::CounterpartyResource.create_counterparty(request)
+      end
+
+      # Create counterparty with plaid token
+      # @see https://docs.unit.co/payments-counterparties/#create-counterparty-with-plaid-token
+      # @param customer_id [String]
+      # @param type [String]
+      # @param name [String]
+      # @param plaid_processor_token [String]
+      # @param verify_name [Boolean] - optional
+      # @param permissions [String] - optional
+      # @param tags [Hash] - optional
+      # @param idempotency_key [String] - optional
+      def create_with_plaid_token(customer_id:, type:, name:, plaid_processor_token:, verify_name: nil, permissions: nil, tags: nil, idempotency_key: nil)
+        request = CreateWithPlaidTokenRequest.new(customer_id, type, name, plaid_processor_token, verify_name, permissions, tags, idempotency_key)
+        Unit::Resource::CounterpartyResource.create_counterparty(request)
+      end
+
+      # List counterparties
+      # @see https://docs.unit.co/payments-counterparties/#list-counterparties
+      # @param limit [Integer] - optional
+      # @param offset [Integer] - optional
+      # @param customer_id [String] - optional
+      # @param account_number [String] - optional
+      # @param routing_number [String] - optional
+      # @param tags [Hash] - optional
+      # @param permissions [Array<String>] - optional
+      def list_counterparty(limit: COUNTER_PARTY_LIMIT, offset: COUNTER_PARTY_OFFSET, customer_id: nil, account_number: nil, routing_number: nil, tags: nil, permissions: nil)
+        params = ListCounterpartyParams.new(limit, offset, customer_id, account_number, routing_number, tags, permissions)
+        Unit::Resource::CounterpartyResource.list(params)
+      end
+
+      # Get counterparty by id
+      # @param counterparty_id [String]
+      # @see https://docs.unit.co/payments-counterparties/#get-one-counterparty
+      def get_counterparty(counterparty_id:)
+        Unit::Resource::CounterpartyResource.get_counterparty(counterparty_id)
+      end
+
+      # Get counterparty balance
+      # @param counterparty_id [String]
+      # @see https://docs.unit.co/payments-counterparties/#get-counterparty-balance
+      def get_counterparty_balance(counterparty_id:)
+        Unit::Resource::CounterpartyResource.get_counterparty_balance(counterparty_id)
+      end
+
+      # Update counterparty
+      # @see https://docs.unit.co/payments-counterparties/#list-counterparties
+      # @param counterparty_id [String]
+      # @param plaid_processor_token [String]
+      # @param verify_name [Boolean] - optional
+      # @param permissions [String] - optional
+      # @param tags [Hash] - optional
+      def update_counterparty(counterparty_id:, plaid_processor_token: nil, verify_name: nil, permissions: nil, tags: nil)
+        request = UpdateCounterpartyRequest.new(counterparty_id, plaid_processor_token, verify_name, permissions, tags)
+        Unit::Resource::CounterpartyResource.update_counterparty(request)
+      end
+
+      # Delete counterparty
+      # @param counterparty_id [String]
+      # @see https://docs.unit.co/payments-counterparties/#get-one-counterparty
+      def delete_counterparty(counterparty_id:)
+        Unit::Resource::CounterpartyResource.delete(counterparty_id)
+      end
+    end
+  end
+end

data/lib/unit/models/counterparty/create_counterparty_request.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Request to create a counterparty
+# @see https://docs.unit.co/payments-counterparties/#create-counterparty
+module Unit
+  module Counterparty
+    class CreateCounterpartyRequest
+      attr_reader :customer_id, :name, :routing_number, :account_number, :account_type,
+                  :type, :tags, :permissions, :idempotency_key
+
+      # @param customer_id [String]
+      # @param name [String]
+      # @param routing_number [String]
+      # @param account_number [String]
+      # @param account_type [String]
+      # @param type [String]
+      # @param tags [Hash] - optional
+      # @param permissions [String] - optional
+      # @param idempotency_key [String] - optional
+      def initialize(customer_id, name, routing_number, account_number, account_type, type, tags = nil, permissions = nil, idempotency_key = nil)
+        @customer_id = customer_id
+        @name = name
+        @routing_number = routing_number
+        @account_number = account_number
+        @account_type = account_type
+        @type = type
+        @tags = tags
+        @permissions = permissions
+        @idempotency_key = idempotency_key
+      end
+
+      def to_json_api
+        payload = {
+          "data": {
+            "type": "achCounterparty",
+            "attributes": {
+              name: name,
+              routingNumber: routing_number,
+              accountNumber: account_number,
+              accountType: account_type,
+              type: type,
+              tags: tags,
+              permissions: permissions,
+              idempotencyKey: idempotency_key
+            },
+            "relationships": {
+              customer: Unit::Types::Relationship.new("customer", customer_id).to_hash
+            }
+          }
+        }
+        payload[:data][:attributes].compact!
+        payload.to_json
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Request to create a counterparty with plaid token
+# @see https://docs.unit.co/payments-counterparties/#create-counterparty-with-plaid-token
+module Unit
+  module Counterparty
+    class CreateWithPlaidTokenRequest
+      attr_reader :customer_id, :type, :name, :plaid_processor_token,
+                  :verify_name, :permissions, :tags, :idempotency_key
+
+      # @param customer_id [String]
+      # @param type [String]
+      # @param name [String]
+      # @param plaid_processor_token [String]
+      # @param verify_name [Boolean] - optional
+      # @param permissions [String] - optional
+      # @param tags [Hash] - optional
+      # @param idempotency_key [String] - optional
+      def initialize(customer_id, type, name, plaid_processor_token, verify_name = nil, permissions = nil, tags = nil, idempotency_key = nil)
+        @customer_id = customer_id
+        @type = type
+        @name = name
+        @plaid_processor_token = plaid_processor_token
+        @verify_name = verify_name
+        @permissions = permissions
+        @tags = tags
+        @idempotency_key = idempotency_key
+      end
+
+      def to_json_api
+        payload = {
+          "data": {
+            "type": "achCounterparty",
+            "attributes": {
+              type: type,
+              name: name,
+              plaidProcessorToken: plaid_processor_token,
+              verifyName: verify_name,
+              permissions: permissions,
+              tags: tags,
+              idempotencyKey: idempotency_key
+            },
+            "relationships": {
+              customer: Unit::Types::Relationship.new("customer", customer_id).to_hash
+            }
+          }
+        }
+        payload[:data][:attributes].compact!
+        payload.to_json
+      end
+    end
+  end
+end

data/lib/unit/models/counterparty/list_counterparty_params.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Request to list counterparties
+# @see https://docs.unit.co/payments-counterparties/#list-counterparties
+module Unit
+  module Counterparty
+    class ListCounterpartyParams
+      attr_reader :limit, :offset, :customer_id, :account_number, :routing_number, :tags, :permissions
+
+      # @param limit [Integer] - optional
+      # @param offset [Integer] - optional
+      # @param customer_id [String] - optional
+      # @param account_number [String] - optional
+      # @param routing_number [String] - optional
+      # @param tags [Hash] - optional
+      # @param permissions [Array<String>] - optional
+      def initialize(limit = COUNTER_PARTY_LIMIT, offset = COUNTER_PARTY_OFFSET, customer_id = nil,
+                     account_number = nil, routing_number = nil, tags = nil, permissions = nil)
+        @limit = limit
+        @offset = offset
+        @customer_id = customer_id
+        @account_number = account_number
+        @routing_number = routing_number
+        @tags = tags
+        @permissions = permissions
+      end
+
+      def to_hash
+        params =
+          {
+            "page[limit]": limit,
+            "page[offset]": offset,
+            "filter[customerId]": customer_id,
+            "filter[accountNumber]": account_number,
+            "filter[routingNumber]": routing_number,
+            "filter[tags]": tags
+          }
+        permissions&.each_with_index&.map do |val, index|
+          params.merge!({ "filter[permissions][#{index}]": val })
+        end
+        params.compact
+      end
+    end
+  end
+end

data/lib/unit/models/counterparty/update_counterparty_request.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Request to update a counterparty
+# @see https://docs.unit.co/payments-counterparties/#list-counterparties
+module Unit
+  module Counterparty
+    class UpdateCounterpartyRequest
+      attr_reader :counterparty_id, :plaid_processor_token, :verify_name, :permissions, :tags
+
+      # @param counterparty_id [String]
+      # @param plaid_processor_token [String]
+      # @param verify_name [Boolean] - optional
+      # @param permissions [String] - optional
+      # @param tags [Hash] - optional
+      def initialize(counterparty_id, plaid_processor_token, verify_name = nil, permissions = nil, tags = nil)
+        @counterparty_id = counterparty_id
+        @plaid_processor_token = plaid_processor_token
+        @verify_name = verify_name
+        @permissions = permissions
+        @tags = tags
+      end
+
+      def to_json_api
+        payload = {
+          "data": {
+            "type": "counterparty",
+            attributes: {
+              plaidProcessorToken: plaid_processor_token,
+              verifyName: verify_name,
+              permissions: permissions,
+              tags: tags
+            }
+          }
+        }
+        payload[:data][:attributes].compact!
+        payload.to_json
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Request to create a new ach payment to inline counterparty by calling Unit's API
+# @see https://docs.unit.co/ach-origination#payment-inline-counterparty
+module Unit
+  module Payment
+    class CreateAchPaymentInlineRequest
+      attr_reader :account_id, :amount, :direction, :counterparty, :description,
+                  :addenda, :idempotency_key, :tags, :same_day, :sec_code
+
+      # @param account_id [String]
+      # @param amount [Integer]
+      # @param direction [String]
+      # @param counterparty [Counterparty]
+      # @param description [String]
+      # @param addenda [String] - optional
+      # @param idempotency_key [String] - optional
+      # @param tags [Hash] - optional
+      # @param same_day [Boolean] - optional
+      # @param sec_code [String] - optional
+      def initialize(account_id, amount, direction, counterparty, description,
+                     addenda = nil, idempotency_key = nil, tags = nil, same_day = nil, sec_code = nil)
+        @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
+      end
+
+      def to_json_api
+        payload = {
+          "data": {
+            "type": "achPayment",
+            "attributes": {
+              amount: amount,
+              direction: direction,
+              counterparty: counterparty.represent,
+              description: description,
+              addenda: addenda,
+              idempotencyKey: idempotency_key,
+              tags: tags,
+              sameDay: same_day,
+              secCode: sec_code
+            },
+            "relationships": {
+              "account": Unit::Types::Relationship.new("account", account_id).to_hash
+            }
+          }
+        }
+        payload[:data][:attributes].compact!
+        payload.to_json
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# Request to create a new ach payment to linked counterparty by calling Unit's API
+# @see https://docs.unit.co/ach-origination#payment-linked-counterparty
+module Unit
+  module Payment
+    class CreatePaymentLinkedRequest
+      attr_reader :account_id, :counterparty_id, :amount, :direction, :description,
+                  :addenda, :idempotency_key, :tags, :verify_counterparty_balance,
+                  :same_day, :sec_code
+
+      # @param account_id [String]
+      # @param counterparty_id [String]
+      # @param amount [Integer]
+      # @param direction [String]
+      # @param description [String]
+      # @param addenda [String] - optional
+      # @param idempotency_key [String] - optional
+      # @param tags [Hash] - optional
+      # @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)
+        @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
+      end
+
+      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
+            }
+          }
+        }
+        payload[:data][:attributes].compact!
+        payload.to_json
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Request to create a wire payment by calling Unit's API
+# @see https://docs.unit.co/wires#wire-payments
+module Unit
+  module Payment
+    class CreateWirePaymentRequest
+      attr_reader :account_id, :amount, :description, :counterparty, :idempotency_key, :tags
+
+      # @param account_id [String]
+      # @param amount [Integer]
+      # @param description [String]
+      # @param counterparty [WireCounterparty]
+      # @param idempotency_key [String] - optional
+      # @param tags [Hash] - optional
+      def initialize(account_id, amount, description, counterparty, idempotency_key = nil, tags = nil)
+        @account_id = account_id
+        @amount = amount
+        @description = description
+        @counterparty = counterparty
+        @idempotency_key = idempotency_key
+        @tags = tags
+      end
+
+      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 }
+          }
+        }
+        payload[:data][:attributes].compact!
+        payload.to_json
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# Request to create a new ach payment with a plaid token by calling Unit's API
+# @see https://docs.unit.co/ach-origination#create-ach-payment-with-plaid-token
+module Unit
+  module Payment
+    class CreateWithPlaidTokenRequest
+      attr_reader :account_id, :amount, :direction, :description,
+                  :plaid_processor_token, :addenda, :idempotency_key,
+                  :counterparty_name, :tags, :verify_counterparty_balance,
+                  :same_day, :sec_code
+
+      # @param account_id [String]
+      # @param amount [Integer]
+      # @param direction [String]
+      # @param description [String]
+      # @param plaid_processor_token [String]
+      # @param addenda [String] - optional
+      # @param idempotency_key [String] - optional
+      # @param counterparty_name [String] - optional
+      # @param tags [Hash] - optional
+      # @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)
+        @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
+      end
+
+      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
+            }
+          }
+        }
+        payload[:data][:attributes].compact!
+        payload.to_json
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Request to get payment by id
+# @see https://docs.unit.co/payments#get-specific-payment
+module Unit
+  module Payment
+    class GetRequest
+      attr_reader :payment_id, :include
+
+      # @param payment_id [String]
+      # @param include [Array<String>] - optional
+      def initialize(payment_id, include = nil)
+        @payment_id = payment_id
+        @include = include
+      end
+
+      def to_hash
+        { include: include&.join(",") }.compact
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# Params to list payments
+# @see https://docs.unit.co/payments#list-payments
+
+module Unit
+  module Payment
+    class ListPaymentParams
+      attr_reader :limit, :offset, :account_id, :customer_id, :counterparty_account_id, :tags, :status, :type, :direction, :since, :_until, :from_amount, :to_amount, :recurring_payment_id, :feature, :sort, :include
+
+      # @param limit [Integer] - optional
+      # @param offset [Integer] - optional
+      # @param account_id [String] - optional
+      # @param customer_id [String] - optional
+      # @param counterparty_account_id [String] - optional
+      # @param tags [Hash] - optional
+      # @param status [Array<String>] - optional
+      # @param type [Array<String>] - optional
+      # @param direction [Array<String>] - optional
+      # @param since [String] - optional
+      # @param _until [String] - optional
+      # @param from_amount [Integer] - optional
+      # @param to_amount [Integer] - optional
+      # @param recurring_payment_id [String] - optional
+      # @param feature [Array<String>] - optional
+      # @param sort [String] - optional
+      # @param include [Array<String>] - optional
+      def initialize(limit = PAYMENT_LIMIT, offset = PAYMENT_OFFSET, account_id = nil, customer_id = nil,
+                     counterparty_account_id = nil, tags = nil, status = nil,
+                     type = nil, direction = nil, since = nil, _until = nil,
+                     from_amount = nil, to_amount = nil, recurring_payment_id = nil,
+                     feature = nil, sort = nil, include = nil)
+        @limit = limit
+        @offset = offset
+        @account_id = account_id
+        @customer_id = customer_id
+        @counterparty_account_id = counterparty_account_id
+        @tags = tags
+        @status = status
+        @type = type
+        @direction = direction
+        @since = since
+        @until = _until
+        @from_amount = from_amount
+        @to_amount = to_amount
+        @recurring_payment_id = recurring_payment_id
+        @feature = feature
+        @sort = sort
+        @include = include
+      end
+
+      def to_hash
+        params = {
+          "page[limit]": limit,
+          "page[offset]": offset,
+          "filter[accountId]": account_id,
+          "filter[customerId]": customer_id,
+          "filter[counterpartyAccountId]": counterparty_account_id,
+          "filter[tags]": tags,
+          "filter[since]": since,
+          "filter[until]": _until,
+          "filter[fromAmount]": from_amount,
+          "filter[toAmount]": to_amount,
+          "filter[recurringPaymentId]": recurring_payment_id,
+          sort: sort,
+          include: include&.join(",")
+        }
+        filters = %i[status type direction feature]
+        filters.each do |filter|
+          values = send(filter)
+          values&.each_with_index&.map do |val, index|
+            params.merge!({ "filter[#{filter}][#{index}]": val })
+          end
+        end
+        params.compact
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Request to update an ACH payment
+# @see https://docs.unit.co/ach-origination#update-ach-payment
+module Unit
+  module Payment
+    class PatchAchPaymentRequest
+      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": "achPayment",
+            "attributes": {
+              tags: tags
+            }
+          }
+        }
+        payload[:data][:attributes].compact!
+        payload.to_json
+      end
+    end
+  end
+end