unit_ruby_sdk 0.1.2 → 0.1.4

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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Unit
+  module Account
+    module Deposit
+      ACCOUNT_LIST_LIMIT = 100
+      ACCOUNT_LIST_OFFSET = 0
+      BALANCE_HISTORY_LIMIT = 100
+      BALANCE_HISTORY_OFFSET = 0
+      autoload :CreateDepositAccountRequest, "unit/models/account/deposit/create_deposit_account_request"
+      autoload :CloseDepositAccountRequest, "unit/models/account/deposit/close_deposit_account_request"
+      autoload :AccountOwnersRequest, "unit/models/account/deposit/account_owners_request"
+      autoload :BalanceHistoryRequest, "unit/models/account/deposit/balance_history_request"
+      autoload :FreezeAccountRequest, "unit/models/account/deposit/freeze_account_request"
+      autoload :ListAccountParams, "unit/models/account/deposit/list_account_params"
+      autoload :PatchDepositAccountRequest, "unit/models/account/deposit/patch_deposit_account_request"
+
+      class << self
+        # Create a deposit account
+        # @see https://docs.unit.co/deposit-accounts#create-deposit-account
+        # @param deposit_product [String]
+        # @param tags [Hash]- optional
+        # @param idempotency_key [String] - optional
+        # @param relationships [Relationships, RelationshipArray] - optional
+        # @return [UnitResponse, UnitError]
+        def create_deposit_account(deposit_product:, tags: nil, relationships: nil, idempotency_key: nil)
+          request = CreateDepositAccountRequest.new(deposit_product, tags, relationships, idempotency_key)
+          Unit::Resource::AccountResource.create_account(request)
+        end
+
+        # Close deposit account
+        # @see https://docs.unit.co/deposit-accounts#close-account
+        # @param account_id [String]
+        # @param reason [String]
+        # @param fraud_reason [String] - optional
+        # @return [UnitResponse, UnitError]
+        def close_deposit_account(account_id:, reason:)
+          request = CloseDepositAccountRequest.new(account_id, reason)
+          Unit::Resource::AccountResource.close_account(request)
+        end
+
+        # Reopen deposit account
+        # @see https://docs.unit.co/deposit-accounts#reopen-account
+        # @param account_id [String]
+        # @param reason [String]
+        def reopen_account(account_id:)
+          Unit::Resource::AccountResource.reopen_account(account_id)
+        end
+
+        # Get a deposit account by id
+        # @see https://docs.unit.co/deposit-accounts#get-specific-deposit-account
+        # @param account_id [String]
+        def get_deposit_account(account_id:)
+          Unit::Resource::AccountResource.get_account(account_id)
+        end
+
+        # Freeze deposit account
+        # @see https://docs.unit.co/deposit-accounts#freeze-account
+        # @param account_id [String]
+        # @param reason [String]
+        # @param reason_text [String] - optional
+        # @return [UnitResponse, UnitError]
+        def freeze_account(account_id:, reason:, reason_text: nil)
+          request = FreezeAccountRequest.new(account_id, reason, reason_text)
+          Unit::Resource::AccountResource.freeze_account(request)
+        end
+
+        # Unfreeze deposit account
+        # @see https://docs.unit.co/deposit-accounts#freeze-account
+        # @param account_id [String]
+        # @return [UnitResponse, UnitError]
+        def unfreeze_account(account_id:)
+          Unit::Resource::AccountResource.unfreeze_account(account_id)
+        end
+
+        # Listing deposit accounts
+        # @see https://docs.unit.co/deposit-accounts#list-deposit-accounts
+        # @param limit [Integer] - optional
+        # @param offset [Integer] - optional
+        # @param customer_id [String] - optional
+        # @param tags [Hash] - optional
+        # @param status [String] - optional
+        # @param from_balance [Integer] - optional
+        # @param to_balance [Integer] - optional
+        # @param include [String] - optional
+        # @return [UnitResponse, UnitError]
+        def list_deposit_accounts(limit: ACCOUNT_LIST_LIMIT, offset: ACCOUNT_LIST_OFFSET, customer_id: nil, tags: nil,
+                                  status: nil, from_balance: nil, to_balance: nil, include: nil)
+          request = ListAccountParams.new(limit, offset, customer_id, tags, status, from_balance, to_balance, include)
+          Unit::Resource::AccountResource.list_accounts(request)
+        end
+
+        # Update a deposit account
+        # @see https://docs.unit.co/deposit-accounts#update-accounts
+        # @param account_id [String]
+        # @param tags [Hash] - optional
+        # @param deposit_product [String] - optional
+        # @return [UnitResponse, UnitError]
+        def update_deposit_account(account_id:, tags: nil, deposit_product: nil)
+          request = PatchDepositAccountRequest.new(account_id, tags, deposit_product)
+          Unit::Resource::AccountResource.update_account(request)
+        end
+
+        # Limit a deposit account
+        # @see https://docs.unit.co/deposit-accounts#account-limits
+        # @param account_id [String]
+        # @return [UnitResponse, UnitError]
+        def limits(account_id:)
+          Unit::Resource::AccountResource.limits(account_id)
+        end
+
+        # Get deposit products
+        # @see https://docs.unit.co/deposit-accounts#account-deposit-products
+        # @param account_id [String]
+        # @return [UnitResponse, UnitError]
+        def get_deposit_products(account_id:)
+          Unit::Resource::AccountResource.get_deposit_products(account_id)
+        end
+
+        # Get account balance history by calling Unit's API
+        # @see https://docs.unit.co/deposit-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
+        # @return [UnitResponse, UnitError]
+        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
+
+        # Add account owners by calling Unit's API
+        # @see https://docs.unit.co/deposit-accounts#account-add-owners
+        # @param account_id [String]
+        # @param customers [Array<String>]
+        # @return [UnitResponse, UnitError]
+        def add_owners(account_id:, customers:)
+          request = AccountOwnersRequest.new(account_id, customers)
+          Unit::Resource::AccountResource.add_owners(request)
+        end
+
+        # Remove account owners by calling Unit's API
+        # @see https://docs.unit.co/deposit-accounts#account-remove-owners
+        # @param account_id [String]
+        # @param customers [Array<Customer>]
+        # @return [UnitResponse, UnitError]
+        def remove_owners(account_id:, customers:)
+          request = AccountOwnersRequest.new(account_id, customers)
+          Unit::Resource::AccountResource.remove_owners(request)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Request to add or remove owners to a deposit account
+# @see https://docs.unit.co/deposit-accounts#account-add-owners
+# @see https://docs.unit.co/deposit-accounts#account-remove-owners
+module Unit
+  module Account
+    module Deposit
+      class AccountOwnersRequest
+        attr_reader :account_id, :customers
+
+        # @param account_id [String]
+        # @param customers [Array<String>]
+        def initialize(account_id, customers)
+          @account_id = account_id
+          @customers = customers
+        end
+
+        def to_json_api
+          customers_hash = customers.map do |customer|
+            { "type": "customer", "id": customer }
+          end
+          result = { data: customers_hash }
+          result.to_json
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Request to get the balance history of a deposit account
+# @see https://docs.unit.co/deposit-accounts#get-account-balance-history
+module Unit
+  module Account
+    module Deposit
+      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/deposit/close_deposit_account_request.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Request to close a deposit account
+# @see https://docs.unit.co/deposit-accounts#close-account
+module Unit
+  module Account
+    module Deposit
+      class CloseDepositAccountRequest
+        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: "accountClose",
+              attributes: {
+                reason: reason,
+                fraudReason: fraud_reason
+              }
+            }
+          }
+          payload[:data][:attributes].compact!
+          payload.to_json
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Request to create a deposit account
+# @see https://docs.unit.co/deposit-accounts#create-deposit-account
+module Unit
+  module Account
+    module Deposit
+      class CreateDepositAccountRequest
+        attr_reader :deposit_product, :tags, :idempotency_key, :relationships
+
+        # @param deposit_product [String]
+        # @param tags [Hash]- optional
+        # @param idempotency_key [String] - optional
+        # @param relationships [Relationship, RelationshipArray] - optional
+        def initialize(deposit_product, tags = nil, relationships = nil, idempotency_key = nil)
+          @deposit_product = deposit_product
+          @tags = tags
+          @idempotency_key = idempotency_key
+          @relationships = relationships
+        end
+
+        def to_json_api
+          payload = {
+            data: {
+              type: "depositAccount",
+              attributes: {
+                depositProduct: deposit_product,
+                tags: tags
+              },
+              relationships: relationships
+            }
+          }
+          payload[:data][:attributes].compact!
+          payload.to_json
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Request to freeze a deposit account
+# @see https://docs.unit.co/deposit-accounts#freeze-account
+module Unit
+  module Account
+    module Deposit
+      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: "accountFreeze",
+              attributes: {
+                reason: reason,
+                reasonText: reason_text
+              }
+            }
+          }
+          payload[:data][:attributes].compact!
+          payload.to_json
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# params for listing deposit accounts
+# @see https://docs.unit.co/deposit-accounts#list-deposit-accounts
+module Unit
+  module Account
+    module Deposit
+      class ListAccountParams
+        attr_reader :limit, :offset, :customer_id, :tags, :status,
+                    :from_balance, :to_balance, :include
+
+        # @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
+        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)
+          @limit = limit
+          @offset = offset
+          @customer_id = customer_id
+          @tags = tags
+          @status = status
+          @from_balance = from_balance
+          @to_balance = to_balance
+          @include = include
+        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,
+                     "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/deposit/patch_deposit_account_request.rb

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

data/lib/unit/models/api_token/api_token.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Unit
+  module ApiToken
+    module Org
+      autoload :CreateApiTokenRequest, "unit/models/api_token/org/create_api_token_request"
+
+      class << self
+        # Create a new Org API api_token by calling Unit's API
+        # @see https://docs.unit.co/org-api-tokens#create-org-api-token
+        # @param user_id [String]
+        # @param description [String]
+        # @param scope [Array<String>]
+        # @param expiration [Datetime]
+        # @param source_ip [String] - optional
+        # @param resources [Array<RestrictedResource>] - optional
+        # @return [UnitResponse, UnitError]
+        def create_api_token(user_id:, description:, scope:, expiration:, source_ip: nil, resources: nil)
+          request = CreateApiTokenRequest.new(user_id, description, scope, expiration, source_ip, resources)
+          Unit::Resource::ApiTokenResource.create_org_api_token(request)
+        end
+
+        # Get Org API tokens by calling Unit's API
+        # @see https://docs.unit.co/org-api-tokens#list-org-api-tokens
+        # @param user_id [String]
+        # @return [UnitResponse, UnitError]
+        def list_tokens(user_id:)
+          Unit::Resource::ApiTokenResource.list_org_tokens(user_id)
+        end
+
+        # Revoke Org API api_token by calling Unit's API
+        # @see https://docs.unit.co/org-api-tokens#revoke-org-api-token
+        # @param user_id [String]
+        # @param token_id [String]
+        # @return [UnitResponse, UnitError]
+        def revoke_token(user_id:, token_id:)
+          Unit::Resource::ApiTokenResource.revoke_org_token(user_id, token_id)
+        end
+      end
+    end
+
+    module Customer
+      autoload :CreateCustomerTokenRequest, "unit/models/api_token/customer/create_customer_token_request"
+      autoload :CreateTokenUsingJwtRequest, "unit/models/api_token/customer/create_token_using_jwt_request"
+      autoload :CreateCustomerTokenVerification, "unit/models/api_token/customer/create_customer_token_verification"
+
+      class << self
+        # Create customer token by calling Unit's API
+        # @see https://docs.unit.co/customer-api-tokens#customers-create-customer-bearer-token
+        # @param customer_id [String]
+        # @param scope [Array<String>]
+        # @param verification_token [String]
+        # @param verification_code [String] - optional
+        # @param expires_in [Integer] - optional
+        # @param resources [Array<RestrictedResource>] - optional
+        # @return [UnitResponse, UnitError]
+        def create_customer_token(customer_id:, scope:, verification_token:, verification_code: nil, expires_in: nil,
+                                  resources: nil)
+          request = CreateCustomerTokenRequest.new(customer_id, scope, verification_token, verification_code, expires_in, resources)
+          Unit::Resource::ApiTokenResource.create_customer_token(request)
+        end
+
+        # Create customer token using JWT by calling Unit's API
+        # @see https://docs.unit.co/customer-api-tokens#customers-create-customer-bearer-token-jwt
+        # @param customer_id [String]
+        # @param scope [Array<String>]
+        # @param jwt_token [String] - optional
+        # @return [UnitResponse, UnitError]
+        def create_customer_token_with_jwt(customer_id:, scope:, jwt_token: nil)
+          request = CreateTokenUsingJwtRequest.new(customer_id, scope, jwt_token)
+          Unit::Resource::ApiTokenResource.create_customer_token(request)
+        end
+
+        # Create customer token verification by calling Unit's API
+        # @see https://docs.unit.co/customer-api-tokens#customers-customer-token-verification
+        # @param customer_id [String]
+        # @param channel [String]
+        # @param phone [Phone] - optional
+        # @param app_hash [String] - optional
+        # @param language [String] - optional
+        # @return [UnitResponse, UnitError]
+        def create_customer_token_verification(customer_id:, channel:, phone: nil, app_hash: nil, language: nil)
+          request = CreateCustomerTokenVerification.new(customer_id, channel, phone, app_hash, language)
+          Unit::Resource::ApiTokenResource.create_token_verification(request)
+        end
+      end
+    end
+  end
+end

data/lib/unit/models/api_token/customer/create_customer_token_request.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Request to create a customer token
+# @see https://docs.unit.co/customer-api-tokens#customers-create-customer-bearer-token
+module Unit
+  module ApiToken
+    module Customer
+      class CreateCustomerTokenRequest
+        attr_reader :customer_id, :scope, :verification_token, :verification_code, :expires_in, :resources
+
+        # @param customer_id [String]
+        # @param scope [Array<String>]
+        # @param verification_token [String] - optional
+        # @param verification_code [String] - optional
+        # @param expires_in [Integer] - optional
+        # @param resources [Array<RestrictedResource>] - optional
+        def initialize(customer_id, scope, verification_token, verification_code = nil,
+                       expires_in = nil, resources = nil)
+          @customer_id = customer_id
+          @scope = scope
+          @verification_token = verification_token
+          @verification_code = verification_code
+          @expires_in = expires_in
+          @resources = resources
+        end
+
+        def to_json_api
+          result = { data: { type: "customerToken",
+                             attributes:
+                               { scope: scope&.join(" "),
+                                 verificationToken: verification_token,
+                                 verificationCode: verification_code,
+                                 expiresIn: expires_in,
+                                 resources: resources } } }
+          result[:data][:attributes].compact!
+          result.to_json
+        end
+      end
+    end
+  end
+end

data/lib/unit/models/api_token/customer/create_customer_token_verification.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Request to create a customer token verification
+# @see https://docs.unit.co/customer-api-tokens#customers-customer-token-verification
+module Unit
+  module ApiToken
+    module Customer
+      class CreateCustomerTokenVerification
+        attr_reader :customer_id, :channel, :phone, :app_hash, :language
+
+        # @param customer_id [String]
+        # @param channel [String]
+        # @param phone [Phone] - optional
+        # @param app_hash [String] - optional
+        # @param language [String] - optional
+        def initialize(customer_id, channel, phone = nil, app_hash = nil, language = nil)
+          @customer_id = customer_id
+          @channel = channel
+          @phone = phone
+          @app_hash = app_hash
+          @language = language
+        end
+
+        def to_json_api
+          result = { data: { type: "customerTokenVerification",
+                             attributes:
+                               { channel: channel,
+                                 phone: phone&.represent,
+                                 appHash: app_hash,
+                                 language: language } } }
+          result[:data][:attributes].compact!
+          result.to_json
+        end
+      end
+    end
+  end
+end

data/lib/unit/models/api_token/customer/create_token_using_jwt_request.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Request to create Customer token using JWT
+# @see https://docs.unit.co/customer-api-tokens#customers-create-customer-bearer-token-jwt
+module Unit
+  module ApiToken
+    module Customer
+      class CreateTokenUsingJwtRequest
+        attr_reader :customer_id, :scope, :jwt_token
+
+        # @param scope [Array<String>]
+        # @param jwt_token [String]
+        def initialize(customer_id, scope, jwt_token = nil)
+          @customer_id = customer_id
+          @scope = scope
+          @jwt_token = jwt_token
+        end
+
+        def to_json_api
+          result = { data: { type: "customerToken",
+                             attributes:
+                               { scope: scope&.join(" "),
+                                 jwtToken: jwt_token } } }
+          result[:data][:attributes].compact!
+          result.to_json
+        end
+      end
+    end
+  end
+end

data/lib/unit/models/api_token/org/create_api_token_request.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Request to create an org API token
+# @see https://docs.unit.co/org-api-tokens#create-org-api-token
+module Unit
+  module ApiToken
+    module Org
+      class CreateApiTokenRequest
+        attr_reader :user_id, :description, :scope, :expiration, :source_ip, :resources
+
+        # @param user_id [String]
+        # @param description [String]
+        # @param scope [String]
+        # @param expiration [String]
+        # @param source_ip [String] - optional
+        # @param resources [Array<RestrictedResource>] - optional
+        def initialize(user_id, description, scope, expiration, source_ip = nil, resources = nil)
+          @user_id = user_id
+          @description = description
+          @scope = scope
+          @expiration = expiration
+          @source_ip = source_ip
+          @resources = resources
+        end
+
+        def to_json_api
+          result = { data: { type: "apiToken",
+                             attributes:
+                               { description: description,
+                                 scope: scope,
+                                 expiration: expiration,
+                                 sourceIp: source_ip,
+                                 resources: resources } } }
+          result[:data][:attributes].compact!
+          result.to_json
+        end
+      end
+    end
+  end
+end