atrium-ruby 1.3.2 → 2.0.0

data/lib/atrium/credential.rb

@@ -1,11 +0,0 @@
-module Atrium
-  class Credential
-    include ::ActiveAttr::Model
-
-    attribute :field_name
-    attribute :guid
-    attribute :label
-    attribute :type
-    attribute :value
-  end
-end

data/lib/atrium/error.rb

@@ -1,4 +0,0 @@
-module Atrium
-  class Error < StandardError
-  end
-end

data/lib/atrium/institution.rb

@@ -1,38 +0,0 @@
-module Atrium
-  class Institution
-    extend ::Atrium::Paginate
-    include ::ActiveAttr::Model
-
-    attribute :code
-    attribute :name
-    attribute :url
-    attribute :small_logo_url
-    attribute :medium_logo_url
-
-    # @todo Normalize params interface across gem, most of gem favors hash
-    def self.credentials(institution_code)
-      endpoint = "/institutions/#{institution_code}/credentials"
-      response = ::Atrium.client.make_request(:get, endpoint)
-
-      response["credentials"].map do |credential|
-        ::Atrium::Credential.new(credential)
-      end
-    end
-
-    def self.read(institution_code:)
-      endpoint = "/institutions/#{institution_code}"
-      response = ::Atrium.client.make_request(:get, endpoint)
-
-      institution_params = response["institution"]
-      ::Atrium::Institution.new(institution_params)
-    end
-
-    def self.list(query_params: nil, limit: nil)
-      paginate_endpoint(:query_params => query_params, :limit => limit)
-    end
-
-    def self.list_in_batches(query_params: nil, limit: nil, &block)
-      paginate_endpoint_in_batches(:query_params => query_params, :limit => limit, &block)
-    end
-  end
-end

data/lib/atrium/member.rb

@@ -1,264 +0,0 @@
-module Atrium
-  class Member
-    extend ::Atrium::Pageable
-    include ::ActiveAttr::Model
-
-    attribute :aggregated_at
-    attribute :connection_status
-    attribute :challenges
-    attribute :guid
-    attribute :has_processed_accounts
-    attribute :has_processed_transactions
-    attribute :identifier
-    attribute :institution_code
-    attribute :is_being_aggregated
-    attribute :metadata
-    attribute :name
-    attribute :status
-    attribute :successfully_aggregated_at
-    attribute :user_guid
-
-    ##
-    # CLASS METHODS
-    #
-    def self.create(user_guid:, institution_code:, credentials:)
-      endpoint = "/users/#{user_guid}/members"
-      body = create_params(institution_code, credentials)
-      member_response = ::Atrium.client.make_request(:post, endpoint, body)
-
-      member_params = member_response["member"]
-      ::Atrium::Member.new(member_params)
-    end
-
-    def self.list(options = {})
-      options = _member_pagination_options(options)
-      paginate(options)
-    end
-
-    def self.list_each(options = {})
-      options = _member_pagination_options(options)
-      paginate_each(options) { |member| yield member }
-    end
-
-    def self.list_in_batches(options = {})
-      options = _member_pagination_options(options)
-      paginate_in_batches(options) { |batch| yield batch }
-    end
-
-    def self.read(user_guid:, member_guid:)
-      endpoint = "/users/#{user_guid}/members/#{member_guid}"
-      member_response = ::Atrium.client.make_request(:get, endpoint)
-
-      member_params = member_response["member"]
-      ::Atrium::Member.new(member_params)
-    end
-
-    ##
-    # INSTANCE METHODS
-    #
-    def accounts(options = {})
-      options = _account_pagination_options(options)
-      self.class.paginate(options)
-    end
-
-    def each_account(options = {})
-      options = _account_pagination_options(options)
-      self.class.paginate_each(options) { |account| yield account }
-    end
-
-    def accounts_in_batches(options = {})
-      options = _account_pagination_options(options)
-      self.class.paginate_in_batches(options) { |batch| yield batch }
-    end
-
-    def aggregate
-      endpoint = "/users/#{user_guid}/members/#{guid}/aggregate"
-      member_response = ::Atrium.client.make_request(:post, endpoint)
-
-      member_params = member_response["member"]
-      assign_attributes(member_params)
-      self
-    end
-
-    def aggregation_status
-      endpoint = "/users/#{user_guid}/members/#{guid}/status"
-      member_response = ::Atrium.client.make_request(:get, endpoint)
-
-      member_params = member_response["member"]
-      assign_attributes(member_params)
-      self
-    end
-
-    def mfa_challenges
-      endpoint = "/users/#{user_guid}/members/#{guid}/challenges"
-      challenge_response = ::Atrium.client.make_request(:get, endpoint)
-
-      return nil if challenge_response.nil?
-
-      challenge_params = challenge_response["challenges"]
-
-      challenge_params.map do |challenge|
-        ::Atrium::Challenge.new(challenge)
-      end
-    end
-
-    def delete
-      endpoint = "/users/#{user_guid}/members/#{guid}"
-      ::Atrium.client.make_request(:delete, endpoint)
-
-      self
-    end
-
-    def read_account(account_guid:)
-      endpoint = "/users/#{user_guid}/members/#{guid}/accounts/#{account_guid}"
-      account_response = ::Atrium.client.make_request(:get, endpoint)
-
-      account_params = account_response["account"]
-      ::Atrium::Account.new(account_params)
-    end
-
-    def resume(challenge_credentials)
-      endpoint = "/users/#{user_guid}/members/#{guid}/resume"
-      body = resume_params(challenge_credentials)
-      member_response = ::Atrium.client.make_request(:put, endpoint, body)
-
-      member_params = member_response["member"]
-      assign_attributes(member_params)
-      self
-    end
-
-    def update(params)
-      endpoint = "/users/#{user_guid}/members/#{guid}"
-      body = member_body(params)
-      member_response = ::Atrium.client.make_request(:put, endpoint, body)
-
-      member_params = member_response["member"]
-      assign_attributes(member_params)
-      self
-    end
-
-    def credentials
-      endpoint = "/users/#{user_guid}/members/#{guid}/credentials"
-      credential_response = ::Atrium.client.make_request(:get, endpoint)
-
-      return nil if credential_response.nil?
-
-      credential_params = credential_response["credentials"]
-
-      credential_params.map do |credential|
-        ::Atrium::Credential.new(credential)
-      end
-    end
-
-    def transactions(options = {})
-      options = _transaction_pagination_options(options)
-      self.class.paginate(options)
-    end
-
-    def each_transaction(options = {})
-      options = _transaction_pagination_options(options)
-      self.class.paginate_each(options) { |transaction| yield transaction }
-    end
-
-    def transactions_in_batches(options = {})
-      options = _transaction_pagination_options(options)
-      self.class.paginate_in_batches(options) { |batch| yield batch }
-    end
-
-    def self._member_pagination_options(options)
-      user_guid = options.fetch(:user_guid)
-      endpoint = "/users/#{user_guid}/members"
-      options.merge(:endpoint => endpoint, :resource => "members")
-    end
-
-    def verify
-      endpoint = "/users/#{user_guid}/members/#{guid}/verify"
-      member_response = ::Atrium.client.make_request(:post, endpoint)
-
-      member_params = member_response["member"]
-      assign_attributes(member_params)
-      self
-    end
-
-    def account_numbers
-      endpoint = "/users/#{user_guid}/members/#{guid}/account_numbers"
-      account_numbers_response = ::Atrium.client.make_request(:get, endpoint)
-
-      return nil if account_numbers_response.nil?
-
-      account_numbers_params = account_numbers_response["account_numbers"]
-
-      account_numbers_params.map do |account_number|
-        ::Atrium::AccountNumber.new(account_number)
-      end
-    end
-
-    def identify
-      endpoint = "/users/#{user_guid}/members/#{guid}/identify"
-      member_response = ::Atrium.client.make_request(:post, endpoint)
-
-      member_params = member_response["member"]
-      assign_attributes(member_params)
-      self
-    end
-
-    def account_owners
-      endpoint = "/users/#{user_guid}/members/#{guid}/account_owners"
-      account_owners_response = ::Atrium.client.make_request(:get, endpoint)
-
-      return nil if account_owners_response.nil?
-
-      account_owners_params = account_owners_response["account_owners"]
-
-      account_owners_params.map do |account_owner|
-        ::Atrium::AccountOwner.new(account_owner)
-      end
-    end
-
-    ##
-    # PRIVATE CLASS METHODS
-    #
-    def self.create_params(institution_code, credentials_array)
-      {
-        :member => {
-          :institution_code => institution_code,
-          :credentials => credentials_array
-        }
-      }
-    end
-    private_class_method :create_params
-
-  private
-
-    ##
-    # PRIVATE INSTANCE METHODS
-    #
-    def _account_pagination_options(options)
-      endpoint = "/users/#{user_guid}/members/#{guid}/accounts"
-      options.merge(:endpoint => endpoint, :resource => "accounts", :klass => ::Atrium::Account)
-    end
-
-    def member_body(params)
-      {
-        :member => {
-          :credentials => params[:credentials],
-          :identifier => params[:identifier],
-          :metadata => params[:metadata]
-        }
-      }
-    end
-
-    def resume_params(challenge_credentials)
-      {
-        :member => {
-          :challenges => challenge_credentials
-        }
-      }
-    end
-
-    def _transaction_pagination_options(options)
-      endpoint = "/users/#{user_guid}/members/#{guid}/transactions"
-      options.merge(:endpoint => endpoint, :resource => "transactions", :klass => ::Atrium::Transaction)
-    end
-  end
-end

data/lib/atrium/pageable.rb

@@ -1,74 +0,0 @@
-module Atrium
-  class PaginationBatch < ::Array
-    attr_accessor :total_pages, :total_entries, :current_page, :records_per_page
-  end
-
-  module Pageable
-    DEFAULT_RECORDS_PER_PAGE = 25
-
-    def make_get_request(endpoint, query_params)
-      uri = endpoint + "?" + ::URI.encode_www_form(query_params.sort)
-      ::Atrium.client.make_request(:get, uri)
-    end
-
-    def paginate(options = {})
-      records_per_page = options.fetch(:records_per_page, DEFAULT_RECORDS_PER_PAGE)
-      results = PaginationBatch.new
-      paginate_in_batches(options.merge(:limit => records_per_page)) do |batch|
-        results = batch
-      end
-      results
-    end
-
-    def paginate_each(options = {})
-      paginate_in_batches(options) do |batch|
-        batch.each do |record|
-          yield record
-        end
-      end
-    end
-
-    def paginate_in_batches(options = {})
-      fail ::ArgumentError, "A block is required" unless block_given?
-
-      endpoint = options.fetch(:endpoint)
-      resource = options.fetch(:resource)
-      klass = options.fetch(:klass, self)
-
-      query_params = options.fetch(:query_params, {})
-      limit = options.fetch(:limit, nil)
-      current_page = options.fetch(:initial_page, 1)
-      records_per_page = options.fetch(:records_per_page, DEFAULT_RECORDS_PER_PAGE)
-
-      pagination_info_query_params = query_params.merge(:records_per_page => records_per_page)
-      pagination = pagination_info(endpoint, pagination_info_query_params)
-      total_pages = pagination["total_pages"]
-      total_entries = pagination["total_entries"]
-      # "total_pages > 1" check exists since some query_params only return 1 page
-      total_pages = limit / records_per_page if limit.present? && total_pages > 1
-
-      until current_page > total_pages
-        params = query_params.merge(:page => current_page, :records_per_page => records_per_page)
-        response = make_get_request(endpoint, params)
-
-        records = response[resource].map { |attributes| klass.new(attributes) }
-
-        batch = ::Atrium::PaginationBatch.new(records)
-        batch.total_pages = total_pages
-        batch.total_entries = total_entries
-        batch.current_page = current_page
-        batch.records_per_page = records_per_page
-        yield batch
-
-        current_page += 1
-      end
-
-      nil
-    end
-
-    def pagination_info(endpoint, query_params)
-      response = make_get_request(endpoint, query_params.merge(:page => 1))
-      response["pagination"]
-    end
-  end
-end

data/lib/atrium/paginate.rb

@@ -1,92 +0,0 @@
-require "uri"
-
-module Atrium
-  module Paginate
-    DEFAULT_RECORDS_PER_PAGE = 25
-    INITIAL_PAGE = 1
-
-    attr_accessor :current_page, :endpoint, :total_pages
-
-    def endpoint_name(query_params: nil)
-      @endpoint = if query_params.present?
-                    "/" + klass_name + "?" + URI.encode_www_form(query_params) + "&"
-                  else
-                    "/" + klass_name + "?"
-                  end
-    end
-
-    # rubocop:disable Style/AccessorMethodName
-    def get_total_pages
-      @current_page = INITIAL_PAGE
-
-      paginated_endpoint = endpoint + "page=#{current_page}&records_per_page=#{records_per_page}"
-      response = ::Atrium.client.make_request(:get, paginated_endpoint)
-
-      pagination = response["pagination"]
-      @total_pages  = pagination["total_pages"]
-    end
-    # rubocop:enable Style/AccessorMethodName
-
-    def klass_name
-      @klass_name ||= name.gsub("Atrium::", "").downcase.pluralize
-    end
-
-    def paginate_endpoint(query_params: nil, limit: nil)
-      endpoint_name(:query_params => query_params)
-      get_total_pages
-      response_list(:limit => limit)
-    end
-
-    def paginate_endpoint_in_batches(query_params: nil, limit: nil, &block)
-      return "method requires block to be passed" unless block_given?
-
-      endpoint_name(:query_params => query_params)
-      get_total_pages
-      response_list_in_batches(:limit => limit, &block)
-    end
-
-    def records_per_page
-      @records_per_page ||= DEFAULT_RECORDS_PER_PAGE
-    end
-
-    def response_list(limit: nil)
-      # "total_pages > 1" check exists since some query_params only return 1 page
-      @total_pages = limit / records_per_page if limit.present? && total_pages > 1
-      list = []
-
-      until current_page > total_pages
-        paginated_endpoint = endpoint + "page=#{current_page}&records_per_page=#{records_per_page}"
-        response = ::Atrium.client.make_request(:get, paginated_endpoint)
-
-        # Add new objects to the list
-        response[klass_name.to_s].each do |params|
-          list << new(params)
-        end
-        @current_page += 1
-      end
-
-      if limit.present?
-        list.first(limit)
-      else
-        list
-      end
-    end
-
-    def response_list_in_batches(limit: nil)
-      # "total_pages > 1" check exists since some query_params only return 1 page
-      @total_pages = limit / records_per_page if limit.present? && total_pages > 1
-
-      until current_page > total_pages
-        paginated_endpoint = endpoint + "page=#{current_page}&records_per_page=#{records_per_page}"
-        response = ::Atrium.client.make_request(:get, paginated_endpoint)
-        list = []
-
-        response[klass_name.to_s].each do |params|
-          list << new(params)
-        end
-        @current_page += 1
-        yield list
-      end
-    end
-  end
-end