unit_ruby_sdk 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: edd56d89aa8ed85ea598e976eb3b3ed6a51e977fa355653f00337e7acd2dbfc4
-  data.tar.gz: 3f45bbad0250f27ddaf7f3dbbff18fdfa9ffcebf04b1c669aef786ca18b4897d
+  metadata.gz: 6e5d766996e30818b915c5c1abae42e583abf6cf3e4c2bbc8035386edb06a83c
+  data.tar.gz: 23db92d5de9879ffd1361201432ae343b3f3beeac8abb8813a9c5a423bcd0dd1
 SHA512:
-  metadata.gz: 9a257ad6168f6d8955dd02fc8fe7257e3443f770f7427ea3f3c1852e8d37e7dd6210d7813dafef6bac6f0179595e2be9798bcfcdbd04334794a4bf899d12b04b
-  data.tar.gz: 3ca7ed3b4580291c5574993dfef66387e9c82f4762ce883fb36c34699dcc1b08c73fe1515c74d4a4d45d85e36118e3390aae5260c1aeabca376cff003511ed70
+  metadata.gz: e0a323e41f06ada5acd1ea07261d15face211c8fa86dbb98cf7e3747c76318766b2a546a7a4de4cd4afbb6106aab90d1aa8dadda2e42436b63dff271be21807d
+  data.tar.gz: 5ac425d5e5e2d44e22b39a773aa2cdb2d15c642e4ff653cb98dbe64c91ca8ed301e3184891b2b0f2e53e7ffcfae4461eb40022bd48b0029dc13321439ed4205d

data/.rubocop.yml

@@ -26,3 +26,9 @@ Metrics/AbcSize:
 
 Layout/LineLength:
   Max: 350
+
+Style/ClassVars:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    unit-ruby-sdk (0.1.0)
+    unit_ruby_sdk (0.1.0)
 
 GEM
   remote: https://rubygems.org/
@@ -115,6 +115,7 @@ GEM
 
 PLATFORMS
   arm64-darwin-21
+  universal-darwin-22
   x86_64-darwin-21
   x86_64-linux
 
@@ -125,7 +126,7 @@ DEPENDENCIES
   rspec
   rubocop (~> 1.21)
   ruby-debug-ide
-  unit-ruby-sdk!
+  unit_ruby_sdk!
 
 BUNDLED WITH
-   2.3.24
+   2.3.25

data/lib/unit/api_resources/application_resource.rb

@@ -1,75 +1,69 @@
 # frozen_string_literal: true
 
 require "httparty"
-
-require_relative "../api_resources/base_resource"
-require_relative "../models/applications/create_business_application_request"
-require_relative "../models/applications/create_individual_application_request"
-require_relative "../models/applications/patch_application_request"
-require_relative "../models/applications/list_application_params"
-
-require_relative "../models/unit_response"
-require_relative "../errors/unit_error"
+require_relative "./base_resource"
 require "json"
-
 # class for creating requests for applications to Unit API and parsing responses
 # See: https://docs.unit.co/applications
 module Unit
-  class ApplicationResource < Unit::BaseResource
-    # Create a new application by calling Unit's API
-    # @param [CreateIndividualApplicationRequest, CreateBusinessApplicationRequest] request
-    # @return [UnitResponse, UnitError]
-    def create_application(request)
-      payload = request.to_json_api
-      response = HTTParty.post("#{api_url}/applications", body: payload, headers: headers)
-      response_handler(response)
-    end
+  module Resource
+    class ApplicationResource < Unit::Resource::BaseResource
+      class << self
+        # Create a new application by calling Unit's API
+        # @param [CreateIndividualApplicationRequest, CreateBusinessApplicationRequest] request
+        # @return [UnitResponse, UnitError]
+        def create_application(request)
+          payload = request.to_json_api
+          response = HTTParty.post("#{api_url}/applications", body: payload, headers: headers)
+          response_handler(response)
+        end
 
-    # Get an application by calling Unit's API
-    # @param [Integer] application_id
-    # @return [UnitResponse, UnitError]
-    def get_application(application_id)
-      response = HTTParty.get("#{api_url}/applications/#{application_id}", headers: headers)
-      response_handler(response)
-    end
-
-    # Get an applications by calling Unit's API
-    # @param [ListApplicationParams] params
-    # @return [UnitResponse, UnitError]
-    def list_applications(params = nil)
-      response = HTTParty.get("#{api_url}/applications", body: params&.to_hash&.to_json, headers: headers)
+        # Get an application by calling Unit's API
+        # @param [Integer] application_id
+        # @return [UnitResponse, UnitError]
+        def get_application(application_id)
+          response = HTTParty.get("#{api_url}/applications/#{application_id}", headers: headers)
+          response_handler(response)
+        end
 
-      response_handler(response)
-    end
+        # Get an applications by calling Unit's API
+        # @param [ListApplicationParams] params
+        # @return [UnitResponse, UnitError]
+        def list_applications(params = nil)
+          response = HTTParty.get("#{api_url}/applications", body: params&.to_hash&.to_json, headers: headers)
+          response_handler(response)
+        end
 
-    # Upload a document to an application
-    # @param [UploadDocumentRequest] request
-    # @return [UnitResponse, UnitError]
-    def upload(request)
-      url = "#{api_url}/applications/#{request.application_id}/documents/#{request.document_id}"
-      url += "/back" if request.is_back_side
+        # Upload a document to an application
+        # @param [UploadDocumentRequest] request
+        # @return [UnitResponse, UnitError]
+        def upload(request)
+          url = "#{api_url}/applications/#{request.application_id}/documents/#{request.document_id}"
+          url += "/back" if request.is_back_side
 
-      headers = {
-        "Authorization" => "Bearer #{token}",
-        "User-Agent" => "unit-ruby-sdk"
-      }
+          headers = {
+            "Authorization" => "Bearer #{token}",
+            "User-Agent" => "unit-ruby-sdk"
+          }
 
-      headers["Content-Type"] = "application/pdf" if request.file_type == "pdf"
-      headers["Content-Type"] = "image/jpeg" if request.file_type == "jpeg"
-      headers["Content-Type"] = "image/png" if request.file_type == "png"
+          headers["Content-Type"] = "application/pdf" if request.file_type == "pdf"
+          headers["Content-Type"] = "image/jpeg" if request.file_type == "jpeg"
+          headers["Content-Type"] = "image/png" if request.file_type == "png"
 
-      response = HTTParty.put(url, body: request.file, headers: headers)
+          response = HTTParty.put(url, body: request.file, headers: headers)
 
-      response_handler(response)
-    end
+          response_handler(response)
+        end
 
-    # Update an application by calling Unit's API
-    # @param [PatchApplicationRequest] request
-    # @return [UnitResponse, UnitError]
-    def update(request)
-      payload = request.to_json_api
-      response = HTTParty.patch("#{api_url}/applications/#{request.application_id}", body: payload, headers: headers)
-      response_handler(response)
+        # Update an application by calling Unit's API
+        # @param [PatchApplicationRequest] request
+        # @return [UnitResponse, UnitError]
+        def update(request)
+          payload = request.to_json_api
+          response = HTTParty.patch("#{api_url}/applications/#{request.application_id}", body: payload, headers: headers)
+          response_handler(response)
+        end
+      end
     end
   end
 end

data/lib/unit/api_resources/base_resource.rb

@@ -3,33 +3,39 @@
 require "httparty"
 
 module Unit
-  class BaseResource
-    attr_reader :api_url, :headers, :token
+  module Resource
+    class BaseResource
+      class << self
+        # Check the response code and return a UnitResponse or UnitError
+        # @param [HTTParty::Response] response
+        def response_handler(response)
+          included = response["included"].nil? ? nil : response["included"]
+          meta = response["meta"].nil? ? nil : response["meta"]
+          case response.code
+          when 200...300
+            Unit::UnitResponse.new(response["data"], included, meta)
+          else
+            Unit::UnitError.from_json_api(response)
+          end
+        end
 
-    # @param api_url [String] The API URL
-    # @param token [String] The API token
-    # @return [BaseResource]
-    def initialize(api_url, token)
-      @api_url = api_url
-      @token = token
-      @headers =
-        {
-          "Content-Type" => "application/vnd.api+json",
-          "Authorization" => "Bearer #{token}",
-          "User-Agent" => "unit-ruby-sdk"
-        }
-    end
+        protected
+
+        def api_url
+          Unit.config[:api_url]
+        end
+
+        def token
+          Unit.config[:token]
+        end
 
-    # Check the response code and return a UnitResponse or UnitError
-    # @param [HTTParty::Response] response
-    def response_handler(response)
-      included = response["included"].nil? ? nil : response["included"]
-      meta = response["meta"].nil? ? nil : response["meta"]
-      case response.code
-      when 200...300
-        UnitResponse.new(response["data"], included, meta)
-      else
-        UnitError.from_json_api(response)
+        def headers
+          {
+            "Content-Type" => "application/vnd.api+json",
+            "Authorization" => "Bearer #{Unit.config[:token]}",
+            "User-Agent" => "unit-ruby-sdk"
+          }
+        end
       end
     end
   end

data/lib/unit/api_resources/customer_resource.rb

@@ -5,65 +5,67 @@ require "httparty"
 require_relative "../api_resources/base_resource"
 require_relative "../models/unit_response"
 require_relative "../errors/unit_error"
-require_relative "../models/customers/patch_individual_customer_request"
-require_relative "../models/customers/patch_business_customer_request"
 
 # class for creating requests for customers to Unit API and parsing responses
 # See: https://docs.unit.co/customers/
 module Unit
-  class CustomerResource < Unit::BaseResource
-    # Update a customer by calling Unit's API
-    # @param [PatchIndividualCustomerRequest, PatchBusinessCustomerRequest, PatchTrustCustomerRequest] request
-    # @return [UnitResponse, UnitError]
-    def update(request)
-      payload = request.to_json_api
-      response = HTTParty.patch("#{api_url}/customers/#{request.customer_id}", body: payload, headers: headers)
-      response_handler(response)
-    end
+  module Resource
+    class CustomerResource < Unit::Resource::BaseResource
+      class << self
+        # Update a customer by calling Unit's API
+        # @param [PatchIndividualCustomerRequest, PatchBusinessCustomerRequest, PatchTrustCustomerRequest] request
+        # @return [UnitResponse, UnitError]
+        def update(request)
+          payload = request.to_json_api
+          response = HTTParty.patch("#{api_url}/customers/#{request.customer_id}", body: payload, headers: headers)
+          response_handler(response)
+        end
 
-    # Get a customer by calling Unit's API
-    # @param [Integer] customer_id
-    # @return [UnitResponse, UnitError]
-    def get(customer_id)
-      response = HTTParty.get("#{api_url}/customers/#{customer_id}", headers: headers)
-      response_handler(response)
-    end
+        # Get a customer by calling Unit's API
+        # @param [String] customer_id
+        # @return [UnitResponse, UnitError]
+        def get(customer_id)
+          response = HTTParty.get("#{api_url}/customers/#{customer_id}", headers: headers)
+          response_handler(response)
+        end
 
-    # Get customers by calling Unit's API
-    # @param [ListCustomerParams] params
-    # @return [UnitResponse, UnitError]
-    def list(params = nil)
-      response = HTTParty.get("#{api_url}/customers", body: params&.to_hash&.to_json, headers: headers)
-      response_handler(response)
-    end
+        # Get customers by calling Unit's API
+        # @param [ListCustomerParams] params
+        # @return [UnitResponse, UnitError]
+        def list(params = nil)
+          response = HTTParty.get("#{api_url}/customers", body: params&.to_hash&.to_json, headers: headers)
+          response_handler(response)
+        end
 
-    # Archive customers by calling Unit's API
-    # @param [ArchiveCustomerRequest] request
-    # @return [UnitResponse, UnitError]
-    def archive(request)
-      payload = request.to_json_api
-      response = HTTParty.post("#{api_url}/customers/#{request.customer_id}/archive", body: payload, headers: headers)
-      response_handler(response)
-    end
+        # Archive customers by calling Unit's API
+        # @param [ArchiveCustomerRequest] request
+        # @return [UnitResponse, UnitError]
+        def archive(request)
+          payload = request.to_json_api
+          response = HTTParty.post("#{api_url}/customers/#{request.customer_id}/archive", body: payload, headers: headers)
+          response_handler(response)
+        end
 
-    # Add authorized users to a customer by calling Unit's API
-    # @param [AddAuthorizedUsersRequest] request
-    # @return [UnitResponse, UnitError]
-    def add_authorized_users(request)
-      payload = request.to_json_api
-      response = HTTParty.post("#{api_url}/customers/#{request.customer_id}/authorized-users",
-                               body: payload,
-                               headers: headers)
-      response_handler(response)
-    end
+        # Add authorized users to a customer by calling Unit's API
+        # @param [AddAuthorizedUsersRequest] request
+        # @return [UnitResponse, UnitError]
+        def add_authorized_users(request)
+          payload = request.to_json_api
+          response = HTTParty.post("#{api_url}/customers/#{request.customer_id}/authorized-users",
+                                   body: payload,
+                                   headers: headers)
+          response_handler(response)
+        end
 
-    # Remove authorized users from a customer by calling Unit's API
-    # @param [RemoveAuthorizedUsersRequest] request
-    # @return [UnitResponse, UnitError]
-    def remove_authorized_users(request)
-      payload = request.to_json_api
-      response = HTTParty.delete("#{api_url}/customers/#{request.customer_id}/authorized-users", body: payload, headers: headers)
-      response_handler(response)
+        # Remove authorized users from a customer by calling Unit's API
+        # @param [RemoveAuthorizedUsersRequest] request
+        # @return [UnitResponse, UnitError]
+        def remove_authorized_users(request)
+          payload = request.to_json_api
+          response = HTTParty.delete("#{api_url}/customers/#{request.customer_id}/authorized-users", body: payload, headers: headers)
+          response_handler(response)
+        end
+      end
     end
   end
 end

data/lib/unit/errors/unit_error.rb

@@ -11,17 +11,19 @@ module Unit
       @errors = errors
     end
 
-    # Creates a new UnitError from given response.
-    # @param [Hash] response The response returned from Unit's API
-    # @return [UnitError] a new UnitError populated with values taken from the response
-    def self.from_json_api(response)
-      errors = response["errors"]
+    class << self
+      # Creates a new UnitError from given response.
+      # @param [Hash] response The response returned from Unit's API
+      # @return [UnitError] a new UnitError populated with values taken from the response
+      def from_json_api(response)
+        errors = response["errors"]
 
-      errors&.map do |error|
-        UnitErrorPayload.new(error["title"], error["status"],
-                             error["detail"], error["details"], error["source"], error["code"])
+        errors&.map do |error|
+          UnitErrorPayload.new(error["title"], error["status"],
+                               error["detail"], error["details"], error["source"], error["code"])
+        end
+        UnitError.new(errors)
       end
-      UnitError.new(errors)
     end
   end
 end

data/lib/unit/models/application/create_business_application_request.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "unit/types/full_name"
+require "unit/types/address"
+require "unit/types/phone"
+require "unit/types/business_contact"
+require "unit/types/beneficial_owner"
+require "unit/types/officer"
+
+# Request to create a business application
+# See: https://docs.unit.co/applications/#create-business-application
+module Unit
+  module Application
+    class CreateBusinessApplicationRequest
+      attr_reader :name, :address, :phone, :state_of_incorporation, :ein, :industry, :contact, :officer, :beneficial_owners,
+                  :entity_type, :dba, :ip, :website, :tags, :idempotency_key, :device_fingerprints, :type
+
+      # @param name [String]
+      # @param address [Address]
+      # @param phone [Phone]
+      # @param state_of_incorporation [String]
+      # @param ein [String]
+      # @param industry [String]
+      # @param contact [BusinessContact]
+      # @param officer [Officer]
+      # @param beneficial_owners [Array]
+      # @param entity_type [String]
+      # @param optional dba [String]
+      # @param optional ip [String]
+      # @param optional website [String]
+      # @param optional tags [Hash]
+      # @param optional idempotency_key [String]
+      # @param optional device_fingerprints [DeviceFingerprint]
+      def initialize(name, address, phone, state_of_incorporation, ein, industry, contact, officer,
+                     beneficial_owners, entity_type, dba = nil, ip = nil, website = nil, tags = nil, idempotency_key = nil,
+                     device_fingerprints = nil)
+        @name = name
+        @address = address
+        @phone = phone
+        @state_of_incorporation = state_of_incorporation
+        @ein = ein
+        @industry = industry
+        @contact = contact
+        @officer = officer
+        @beneficial_owners = beneficial_owners.map(&:represent)
+        @entity_type = entity_type
+        @dba = dba
+        @ip = ip
+        @website = website
+        @tags = tags
+        @idempotency_key = idempotency_key
+        @device_fingerprints = device_fingerprints
+        @type = "businessApplication"
+      end
+
+      def to_json_api
+        payload = {
+          data: {
+            type: type,
+            attributes: {
+              name: name,
+              address: address.represent,
+              phone: phone.represent,
+              stateOfIncorporation: state_of_incorporation,
+              ein: ein,
+              industry: industry,
+              contact: contact.represent,
+              officer: officer.represent,
+              beneficialOwners: beneficial_owners,
+              entityType: entity_type,
+              dba: dba,
+              ip: ip,
+              website: website
+            }
+          }
+        }
+        payload[:data][:attributes].compact!
+        payload.to_json
+      end
+    end
+  end
+end

data/lib/unit/models/application/create_individual_application_request.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "unit/types/full_name"
+require "unit/types/address"
+require "unit/types/phone"
+require "unit/types/device_fingerprint"
+
+# Request to create an individual application
+# See https://docs.unit.co/applications/#create-individual-application
+module Unit
+  module Application
+    class CreateIndividualApplicationRequest
+      attr_reader :type, :ssn, :full_name, :date_of_birth, :address, :email, :phone, :ip, :ein, :industry, :dba, :sole_proprietorship,
+                  :passport, :nationality, :device_fingerprints, :idempotency_key, :tags, :jwt_subject, :power_of_attorney_agent,
+                  :evaluation_params
+
+      # @param ssn [String]
+      # @param full_name [FullName]
+      # @param date_of_birth [Date]
+      # @param address [Address]
+      # @param email [String]
+      # @param phone [Phone]
+      # @param optional ip [String]
+      # @param optional ein [String]
+      # @param optional industry [String]
+      # @param optional dba [String]
+      # @param optional sole_proprietorship [Boolean]
+      # @param optional passport [String]
+      # @param optional nationality [String]
+      # @param optional device_fingerprints [DeviceFingerprint]
+      # @param optional idempotency_key [String]
+      # @param optional tags [Hash]
+      # @param optional jwt_subject [String]
+      # @param optional power_of_attorney_agent [PowerOfAttorneyAgent]
+      # @param optional evaluation_params [EvaluationParams]
+      def initialize(ssn, full_name, date_of_birth, address, email, phone, ip = nil, ein = nil, industry = nil, dba = nil, sole_proprietorship = nil, passport = nil,
+                     nationality = nil, device_fingerprints = nil, idempotency_key = nil, tags = nil, jwt_subject = nil, power_of_attorney_agent = nil,
+                     evaluation_params = nil)
+        @ssn = ssn
+        @full_name = full_name
+        @date_of_birth = date_of_birth
+        @address = address
+        @phone = phone
+        @email = email
+        @ip = ip
+        @ein = ein
+        @industry = industry
+        @dba = dba
+        @sole_proprietorship = sole_proprietorship
+        @passport = passport
+        @nationality = nationality
+        @device_fingerprints = device_fingerprints
+        @idempotency_key = idempotency_key
+        @tags = tags
+        @jwt_object = jwt_subject
+        @power_of_attorney_agent = power_of_attorney_agent
+        @evaluation_params = evaluation_params
+        @type = "individualApplication"
+      end
+
+      def to_json_api
+        payload = {
+          data: {
+            type: type,
+            attributes: {
+              ssn: ssn,
+              fullName: full_name.represent,
+              dateOfBirth: date_of_birth,
+              address: address.represent,
+              email: email,
+              phone: phone.represent,
+              ip: ip,
+              ein: ein,
+              industry: industry,
+              dba: dba,
+              soleProprietorship: sole_proprietorship,
+              passport: passport,
+              nationality: nationality,
+              idempotencyKey: idempotency_key,
+              tags: tags,
+              jwtSubject: jwt_subject,
+              powerOfAttorneyAgent: power_of_attorney_agent&.represent,
+              evaluationParams: evaluation_params&.represent
+            }
+          }
+        }
+        payload[:data][:attributes].compact!
+        payload.to_json
+      end
+    end
+  end
+end

data/lib/unit/models/application/list_application_params.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# params for list applications
+# See: https://docs.unit.co/applications/#list-applications
+module Unit
+  module Application
+    class ListApplicationParams
+      attr_reader :offset, :limit, :email, :tags, :query, :status, :sort
+
+      # @param offset [Integer] Number of resources to skip. See pagination: https://docs.unit.co/#intro-pagination
+      # @param limit [Integer] The limit Maximum number of resources that will be returned. Maximum is 1000 resources.
+      # @param email [String] Filter applications by email address (case sensitive).
+      # @param tags [String] Filter applications by tags. More information regarding tags: https://docs.unit.co/#tags
+      # @param query [String] Search term according to the: https://docs.unit.co/#full-text-search
+      # @param status [String] Filter applications by status: https://docs.unit.co/applications/#application-statuses
+      # @param sort [String] Sorts the resources by the specified field.
+      # @option sort=createdAt for ascending order
+      # @option sort=-createdAt (leading minus sign) for descending order.
+      def initialize(offset = 0, limit = 100, email = nil, tags = nil,
+                     query = nil, status = nil, sort = nil)
+        @offset = offset
+        @limit = limit
+        @email = email
+        @tags = tags
+        @query = query
+        @status = status
+        @sort = sort
+      end
+
+      def to_hash
+        params = { "page[limit]": limit,
+                   "page[offset]": offset,
+                   "filter[email]": email,
+                   "filter[tags]": tags,
+                   "filter[query]": query,
+                   "filter[status]": status,
+                   "sort": sort }
+        params.compact!
+      end
+    end
+  end
+end

data/lib/unit/models/application/patch_application_request.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Request to update application
+# See for updating business application: https://docs.unit.co/applications/#update-business-application
+# See for updating individual application: https://docs.unit.co/applications/#update-individual-application
+module Unit
+  module Application
+    class PatchApplicationRequest
+      attr_reader :application_id, :type, :tags
+
+      # @param application_id [String] The application id
+      # @param type [String] The type
+      # @param optional tags [String] The tags
+      def initialize(application_id, type, tags = nil)
+        @application_id = application_id
+        @type = type
+        @tags = tags
+      end
+
+      # @return [String] The JSON API payload
+      def to_json_api
+        payload = {
+          data: {
+            type: type,
+            attributes: { tags: tags }
+          }
+        }
+        payload[:data][:attributes].compact!
+        payload.to_json
+      end
+    end
+  end
+end