unit_ruby_sdk 0.1.0

data/lib/unit/api_resources/customer_resource.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+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
+
+    # 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 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
+
+    # 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)
+    end
+  end
+end

data/lib/unit/errors/unit_error.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "unit_error_payload"
+
+# Represents an Error returned from Unit's API
+module Unit
+  class UnitError
+    # Create a new UnitError
+    # @param [Array<UnitErrorPayload>] errors
+    def initialize(errors)
+      @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"]
+
+      errors&.map do |error|
+        UnitErrorPayload.new(error["title"], error["status"],
+                             error["detail"], error["details"], error["source"], error["code"])
+      end
+      UnitError.new(errors)
+    end
+  end
+end

data/lib/unit/errors/unit_error_payload.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Unit
+  class UnitErrorPayload
+    attr_reader :title, :status, :detail, :details, :source, :code
+
+    # @param title [String] The title of the error
+    # @param status [String] The HTTP status code
+    # @param detail [String] The additional information about the error
+    # @param details [String] The details of the error
+    # @param source [Hash] The source of the error
+    # @param code [String] A Unit-specific code, uniquely identifying the error type
+    # Check out documentation link for more details: https://docs.unit.co/about-jsonapi/#intro-errors
+    def initialize(title, status, detail, details = nil,
+                   source = nil, code = nil)
+      @title = title
+      @status = status
+      @detail = detail
+      @details = details
+      @source = source
+      @code = code
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# 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
+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

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

@@ -0,0 +1,88 @@
+# 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
+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

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# params for list applications
+# See: https://docs.unit.co/applications/#list-applications
+class ListApplicationParams
+  attr_reader :offset, :limit, :email, :tags, :query, :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

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

@@ -0,0 +1,29 @@
+# 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
+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

data/lib/unit/models/applications/upload_document_request.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Creates request for uploading a document
+# See: https://docs.unit.co/application-documents/#upload-document
+class UploadDocumentRequest
+  attr_reader :application_id, :document_id, :file, :file_type, :content_type, :is_back_side
+
+  # @param application_id [String] The application ID
+  # @param document_id [String] The document ID
+  # @param file [String] The file path
+  # @param file_type [String] The file type
+  # @option file_type [String] :pdf
+  # @option file_type [String] :jpg
+  # @option file_type [String] :png
+  # @param is_back_side [Boolean] The file is back side
+  def initialize(application_id, document_id, file, file_type,
+                 is_back_side = nil)
+    @application_id = application_id
+    @document_id = document_id
+    @file = file
+    @file_type = file_type
+    @is_back_side = is_back_side
+  end
+end

data/lib/unit/models/customers/add_authorized_users_request.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Request to add authorized users to a project
+# See: https://docs.unit.co/customers#add-authorized-users
+class AddAuthorizedUsersRequest
+  attr_reader :customer_id, :authorized_users
+
+  # @param customer_id [String] The id of customer
+  # @param authorized_users [Array<AuthorizedUser>] The authorized users
+  def initialize(customer_id, authorized_users)
+    @customer_id = customer_id
+    @authorized_users = authorized_users
+  end
+
+  def to_json_api
+    payload = {
+      data: {
+        type: "addAuthorizedUsers",
+        attributes: {
+          authorizedUsers: authorized_users.map(&:represent)
+        }
+      }
+    }
+    payload[:data][:attributes].compact!
+    payload.to_json
+  end
+end

data/lib/unit/models/customers/archive_customer_request.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Request to archive customer
+# See: https://docs.unit.co/customers#archive-customer
+class ArchiveCustomerRequest
+  attr_reader :customer_id, :reason
+
+  # @param customer_id [String] The id of customer
+  # @param optional reason [String] The reason for archiving the customer
+  # @option reason [String] Need to be one of the following: Inactive, FraudACHActivity, FraudCardActivity, FraudCheckActivity, FraudApplicationHistory, FraudAccountActivity, FraudClientIdentified, FraudLinkedToFraudulentCustomer.
+  def initialize(customer_id, reason = nil)
+    @customer_id = customer_id
+    @reason = reason
+  end
+
+  def to_json_api
+    payload = {
+      data: {
+        type: "archiveCustomer",
+        attributes: { reason: reason }
+      }
+    }
+    payload[:data][:attributes].compact!
+    payload.to_json
+  end
+end

data/lib/unit/models/customers/list_customer_params.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# params for listing customers
+# See: https://docs.unit.co/customers#list-customers
+class ListCustomerParams
+  attr_reader :limit, :offset, :query, :email, :tags, :status, :sort
+
+  # @param optional limit [Integer] Maximum number of resources that will be returned. Maximum is 1000 resources.
+  # @param optional offset [Integer] Number of resources to skip. See pagination: https://docs.unit.co/#intro-pagination
+  # @param optional query [String] Search term according to the: https://docs.unit.co/#full-text-search
+  # @param optional email [String] Filter customers by email address (case sensitive).
+  # @param optional tags [Hash] Filter customers by tags. More information regarding tags: https://docs.unit.co/#tags
+  # @param optional status [String] Filter customers by status. One of: Active, Archived
+  # @param optional 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(limit = 100, offset = 0, query = nil, email = nil, tags = nil, status = nil,
+                 sort = nil)
+    @limit = limit
+    @offset = offset
+    @query = query
+    @email = email
+    @tags = tags
+    @status = status
+    @sort = sort
+  end
+
+  def to_hash
+    params = { "page[limit]": limit,
+               "page[offset]": offset,
+               "filter[query]": query,
+               "filter[email]": email,
+               "filter[tags]": tags,
+               "filter[status]": status,
+               "sort": sort }
+    params.compact!
+  end
+end

data/lib/unit/models/customers/patch_business_customer_request.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Update business customer information request
+# See: https://docs.unit.co/customers#update-business-customer
+class PatchBusinessCustomerRequest
+  attr_reader :customer_id, :address, :phone, :contact, :authorized_users, :dba, :tags
+
+  # @param customer_id [String] The id of business
+  # @param optional address [Address] The address of business
+  # @param optional phone [Phone] The phone of business
+  # @param optional contact [BusinessContact] The primary contact of the business
+  # @param optional authorized_users [Array<AuthorizedUser>] The authorized users of business
+  # @param optional dba [String] The dba of business. To modify or add needed to specify the new dba name.
+  # @param optional tags [Hash] Provides opportunity to add, update or delete tags from resources with the tags attribute on the corresponding Update operation
+  # more information regarding tags: https://docs.unit.co/#updating-tags
+  def initialize(customer_id, address = nil, phone = nil, contact = nil,
+                 authorized_users = nil, dba = nil, tags = nil)
+    @customer_id = customer_id
+    @address = address
+    @phone = phone
+    @contact = contact
+    @authorized_users = authorized_users
+    @dba = dba
+    @tags = tags
+  end
+
+  def to_json_api
+    payload = {
+      data: {
+        type: "businessCustomer",
+        attributes: {
+          address: address&.represent,
+          phone: phone&.represent,
+          contact: contact&.represent,
+          authorized_users: authorized_users&.map(&:represent),
+          dba: dba,
+          tags: tags
+        }
+      }
+    }
+    payload[:data][:attributes].compact!
+    payload.to_json
+  end
+end

data/lib/unit/models/customers/patch_individual_customer_request.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Update individual customer information request
+# See: https://docs.unit.co/customers#update-individual-customer
+class PatchIndividualCustomerRequest
+  attr_reader :customer_id, :address, :phone, :email, :dba, :authorized_users, :tags, :jwt_subject
+
+  # @param customer_id [String] The id of individual customer
+  # @param optional address [Address] The address of individual customer
+  # @param optional phone [Phone] The phone of individual customer
+  # @param optional email [String] The email of individual customer
+  # @param optional dba [String] The dba of individual customer. If the individual is a sole proprietor who is doing business under a different name.
+  # @param optional authorized_users [Array<AuthorizedUser>] The authorized users of individual customer
+  # @param optional tags [Hash] Provides opportunity to add, update or delete tags from resources with the tags attribute on the corresponding Update operation
+  # @param optional jwt_subject [String] The subject of the JWT
+  # More information regarding JWTSubject: https://docs.unit.co/customer-api-tokens/#customers-create-customer-bearer-token-jwt
+  def initialize(customer_id, address = nil, phone = nil, email = nil, dba = nil, authorized_users = nil, tags = nil, jwt_subject = nil)
+    @customer_id = customer_id
+    @address = address
+    @phone = phone
+    @email = email
+    @dba = dba
+    @authorized_users = authorized_users
+    @tags = tags
+    @jwt_subject = jwt_subject
+  end
+
+  def to_json_api
+    payload = {
+      data: {
+        type: "individualCustomer",
+        attributes: {
+          address: address&.represent,
+          phone: phone&.represent,
+          email: email,
+          dba: dba,
+          authorized_users: authorized_users&.map(&:represent),
+          tags: tags
+        }
+      }
+    }
+    payload[:data][:attributes].compact!
+    payload.to_json
+  end
+end

data/lib/unit/models/customers/remove_authorized_users_request.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Request to remove authorized users from customer
+# See: https://docs.unit.co/customers#remove-authorized-users
+class RemoveAuthorizedUsersRequest
+  attr_reader :customer_id, :authorized_users_emails
+
+  # @param customer_id [String] The id of customer
+  # @param authorized_users_emails [Array<String>] The list of authorized users emails to remove from the customer.
+  def initialize(customer_id, authorized_users_emails)
+    @customer_id = customer_id
+    @authorized_users_emails = authorized_users_emails
+  end
+
+  def to_json_api
+    payload = {
+      data: {
+        type: "removeAuthorizedUsers",
+        attributes: {
+          authorizedUsersEmails: authorized_users_emails
+        }
+      }
+    }
+    payload[:data][:attributes].compact!
+    payload.to_json
+  end
+end

data/lib/unit/models/unit_resource.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# class that represents objects that can be created
+# Unit's resources include applications, customers, cards, accounts, transactions
+class UnitResource
+  attr_reader :id, :type, :attributes, :relationships
+
+  # @param id [String] The resource's ID
+  # @param type [String] The type of the resource
+  # @param attributes [Hash] The attributes
+  # @param relationships [Hash] The relationships
+  def initialize(id, type, attributes, relationships)
+    @id = id
+    @type = type
+    @attributes = attributes
+    @relationships = relationships
+  end
+end

data/lib/unit/models/unit_response.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Represents a response from Unit's API
+class UnitResponse
+  attr_reader :data, :included
+
+  # @param data [Hash] The JSON API payload
+  # @param included [Array] The JSON API payload
+
+  def initialize(data, included, meta)
+    @data = data
+    @included = included
+    @meta = meta
+  end
+end

data/lib/unit/types/address.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Address
+  attr_reader :street, :street2, :city, :state, :postal_code, :country
+
+  # @param street [String]
+  # @param city [String]
+  # @param state [String]
+  # @param postal_code [String]
+  # @param country [String]
+  # @param optional street2 [String]
+  def initialize(street, city, state, postal_code, country, street2 = nil)
+    @street = street
+    @street2 = street2
+    @city = city
+    @state = state
+    @postal_code = postal_code
+    @country = country
+  end
+
+  def represent
+    {
+      street: street,
+      street2: street2,
+      city: city,
+      state: state,
+      postalCode: postal_code,
+      country: country
+    }
+  end
+end