mx-platform-ruby 0.1.1 → 0.2.0

data/lib/mx-platform-ruby/client.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module MXPlatformRuby
-  class Client
-    BASE_URL = 'https://int-api.mx.com'
-
-    attr_accessor :base_url, :password, :username
-
-    def initialize(base_url = BASE_URL, password = nil, username = nil)
-      @base_url = base_url
-      @password = password
-      @username = username
-    end
-
-    def http_client
-      @http_client ||= ::HTTPClient.new
-    end
-
-    def make_request(options = {})
-      body    = ::JSON.dump(options[:request_body]) if options[:request_body]
-      headers = default_headers.merge(options[:headers] || {})
-      url     = "#{base_url}#{options[:endpoint]}"
-      url     = "#{url}?#{::URI.encode_www_form(options[:query_params])}" if options[:query_params]
-      method  = options[:http_method]
-
-      response = http_client.public_send(method, url, body, headers)
-
-      handle_response(response)
-    end
-
-    private
-
-    def default_headers
-      {
-        'Accept': 'application/vnd.mx.api.v1+json',
-        'Authorization': "Basic #{::Base64.urlsafe_encode64("#{username}:#{password}")}",
-        'Content-Type': 'application/json'
-      }
-    end
-
-    def format_response_body(body)
-      ::JSON.parse(body)
-    rescue JSON::ParserError
-      file = ::Tempfile.new
-      file.write(body)
-      file.close
-      file
-    end
-
-    def handle_response(response)
-      # Handle 200-206 responses as acceptable
-      raise ::MXPlatformRuby::Error, "#{response.status}: #{response.body}" unless response.status.between?(200, 206)
-
-      return if response.body.empty?
-
-      format_response_body(response.body)
-    end
-  end
-end

data/lib/mx-platform-ruby/connect_widget.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module MXPlatformRuby
-  class ConnectWidget
-    include ::ActiveAttr::Model
-
-    attribute :connect_widget_url
-    attribute :guid
-
-    def self.request_connect_widget_url(options = {})
-      request_connect_widget_url_options = request_connect_widget_url_options(options)
-      response = ::MXPlatformRuby.client.make_request(request_connect_widget_url_options)
-
-      user_params = response['user']
-      ::MXPlatformRuby::ConnectWidget.new(user_params)
-    end
-
-    # Private class methods
-
-    def self.request_connect_widget_url_options(options)
-      {
-        endpoint: "/users/#{options[:user_guid]}/connect_widget_url",
-        http_method: :post,
-        request_body: {
-          config: {
-            color_scheme: options[:color_scheme],
-            current_institution_code: options[:current_institution_code],
-            current_member_guid: options[:current_member_guid],
-            disable_institution_search: options[:disable_institution_search],
-            include_transactions: options[:include_transactions],
-            is_mobile_webview: options[:is_mobile_webview],
-            mode: options[:mode],
-            ui_message_version: options[:ui_message_version],
-            ui_message_webview_url_scheme: options[:ui_message_webview_url_scheme],
-            update_credentials: options[:update_credentials],
-            wait_for_full_aggregation: options[:wait_for_full_aggregation]
-          }.compact
-        }
-      }
-    end
-    private_class_method :request_connect_widget_url_options
-  end
-end

data/lib/mx-platform-ruby/credential.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module MXPlatformRuby
-  class Credential
-    extend ::MXPlatformRuby::Pageable
-    include ::ActiveAttr::Model
-
-    attribute :display_order
-    attribute :field_name
-    attribute :field_type
-    attribute :guid
-    attribute :label
-
-    def self.list_institution_required_credentials(options = {})
-      options = list_institution_required_credentials_options(options)
-
-      paginate(options)
-    end
-
-    def self.list_member_credentials(options = {})
-      options = list_member_credentials_options(options)
-
-      paginate(options)
-    end
-
-    # Private class methods
-
-    def self.list_institution_required_credentials_options(options)
-      {
-        endpoint: "/institutions/#{options[:institution_code]}/credentials",
-        http_method: :get,
-        query_params: {
-          page: options[:page],
-          records_per_page: options[:records_per_page]
-        }.compact,
-        resource: 'credentials'
-      }
-    end
-    private_class_method :list_institution_required_credentials_options
-
-    def self.list_member_credentials_options(options)
-      {
-        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}/credentials",
-        http_method: :get,
-        query_params: {
-          page: options[:page],
-          records_per_page: options[:records_per_page]
-        }.compact,
-        resource: 'credentials'
-      }
-    end
-    private_class_method :list_member_credentials_options
-  end
-end

data/lib/mx-platform-ruby/enhanced_transaction.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module MXPlatformRuby
-  class EnhancedTransaction
-    include ::ActiveAttr::Model
-
-    attribute :amount
-    attribute :category
-    attribute :description
-    attribute :id
-    attribute :is_bill_pay
-    attribute :is_direct_deposit
-    attribute :is_expense
-    attribute :is_fee
-    attribute :is_income
-    attribute :is_international
-    attribute :is_overdraft_fee
-    attribute :is_payroll_advance
-    attribute :merchant_category_code
-    attribute :merchant_guid
-    attribute :original_description
-    attribute :type
-
-    def self.enhance_transactions(options = {})
-      enhance_transactions_options = enhance_transactions_options(options)
-      response = ::MXPlatformRuby.client.make_request(enhance_transactions_options)
-
-      response['transactions'].map { |attributes| ::MXPlatformRuby::EnhancedTransaction.new(attributes) }
-    end
-
-    # Private class methods
-
-    def self.enhance_transactions_options(options)
-      {
-        endpoint: '/transactions/enhance',
-        http_method: :post,
-        request_body: {
-          transactions: options[:transactions]
-        }.compact
-      }
-    end
-    private_class_method :enhance_transactions_options
-  end
-end

data/lib/mx-platform-ruby/error.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module MXPlatformRuby
-  class Error < StandardError
-  end
-end

data/lib/mx-platform-ruby/holding.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module MXPlatformRuby
-  class Holding
-    extend ::MXPlatformRuby::Pageable
-    include ::ActiveAttr::Model
-
-    attribute :account_guid
-    attribute :cost_basis
-    attribute :created_at
-    attribute :currency_code
-    attribute :cusip
-    attribute :daily_change
-    attribute :description
-    attribute :guid
-    attribute :holding_type
-    attribute :id
-    attribute :market_value
-    attribute :member_guid
-    attribute :metadata
-    attribute :purchase_price
-    attribute :shares
-    attribute :symbol
-    attribute :updated_at
-    attribute :user_guid
-
-    def self.list_holdings_by_member(options = {})
-      options = list_holdings_by_member_options(options)
-
-      paginate(options)
-    end
-
-    def self.list_holdings_by_user(options = {})
-      options = list_holdings_by_user_options(options)
-
-      paginate(options)
-    end
-
-    def self.read_holding(options = {})
-      read_holding_options = read_holding_options(options)
-      response = ::MXPlatformRuby.client.make_request(read_holding_options)
-
-      holding_params = response['holding']
-      ::MXPlatformRuby::Holding.new(holding_params)
-    end
-
-    # Private class methods
-
-    def self.list_holdings_by_member_options(options)
-      {
-        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}/holdings",
-        http_method: :get,
-        query_params: {
-          from_date: options[:from_date],
-          page: options[:page],
-          records_per_page: options[:records_per_page],
-          to_date: options[:to_date]
-        }.compact,
-        resource: 'holdings'
-      }
-    end
-    private_class_method :list_holdings_by_member_options
-
-    def self.list_holdings_by_user_options(options)
-      {
-        endpoint: "/users/#{options[:user_guid]}/holdings",
-        http_method: :get,
-        query_params: {
-          from_date: options[:from_date],
-          page: options[:page],
-          records_per_page: options[:records_per_page],
-          to_date: options[:to_date]
-        }.compact,
-        resource: 'holdings'
-      }
-    end
-    private_class_method :list_holdings_by_user_options
-
-    def self.read_holding_options(options)
-      {
-        endpoint: "/users/#{options[:user_guid]}/holdings/#{options[:holding_guid]}",
-        http_method: :get
-      }
-    end
-    private_class_method :read_holding_options
-  end
-end

data/lib/mx-platform-ruby/institution.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module MXPlatformRuby
-  class Institution
-    extend ::MXPlatformRuby::Pageable
-    include ::ActiveAttr::Model
-
-    attribute :code
-    attribute :medium_logo_url
-    attribute :name
-    attribute :small_logo_url
-    attribute :supports_account_identification
-    attribute :supports_account_statement
-    attribute :supports_account_verification
-    attribute :supports_oauth
-    attribute :supports_transaction_history
-    attribute :url
-
-    def self.list_favorites(options = {})
-      options = list_favorites_options(options)
-
-      paginate(options)
-    end
-
-    def self.list_institutions(options = {})
-      options = list_institutions_options(options)
-
-      paginate(options)
-    end
-
-    def self.read_institution(options = {})
-      read_institution_options = read_institution_options(options)
-      response = ::MXPlatformRuby.client.make_request(read_institution_options)
-
-      institution_params = response['institution']
-      ::MXPlatformRuby::Institution.new(institution_params)
-    end
-
-    # Private class methods
-
-    def self.list_favorites_options(options)
-      {
-        endpoint: '/institutions/favorites',
-        http_method: :get,
-        query_params: {
-          page: options[:page],
-          records_per_page: options[:records_per_page]
-        }.compact,
-        resource: 'institutions'
-      }
-    end
-    private_class_method :list_favorites_options
-
-    def self.list_institutions_options(options)
-      {
-        endpoint: '/institutions',
-        http_method: :get,
-        query_params: {
-          name: options[:name],
-          supports_account_identification: options[:supports_account_identification],
-          supports_account_statement: options[:supports_account_statement],
-          supports_account_verification: options[:supports_account_verification],
-          supports_transaction_history: options[:supports_transaction_history]
-        }.compact,
-        resource: 'institutions'
-      }
-    end
-    private_class_method :list_institutions_options
-
-    def self.read_institution_options(options)
-      {
-        endpoint: "/institutions/#{options[:institution_code]}",
-        http_method: :get
-      }
-    end
-    private_class_method :read_institution_options
-  end
-end

data/lib/mx-platform-ruby/member.rb

@@ -1,242 +0,0 @@
-# frozen_string_literal: true
-
-module MXPlatformRuby
-  class Member
-    extend ::MXPlatformRuby::Pageable
-    include ::ActiveAttr::Model
-
-    attribute :aggregated_at
-    attribute :connection_status
-    attribute :guid
-    attribute :id
-    attribute :institution_code
-    attribute :is_being_aggregated
-    attribute :is_oauth
-    attribute :metadata
-    attribute :name
-    attribute :oauth_window_uri
-    attribute :successfully_aggregated_at
-    attribute :user_guid
-
-    def self.aggregate_member(options = {})
-      aggregate_member_options = aggregate_member_options(options)
-      response = ::MXPlatformRuby.client.make_request(aggregate_member_options)
-
-      member_params = response['member']
-      ::MXPlatformRuby::Member.new(member_params)
-    end
-
-    def self.check_balances(options = {})
-      check_balances_options = check_balances_options(options)
-      response = ::MXPlatformRuby.client.make_request(check_balances_options)
-
-      member_params = response['member']
-      ::MXPlatformRuby::Member.new(member_params)
-    end
-
-    def self.create_member(options = {})
-      create_member_options = create_member_options(options)
-      response = ::MXPlatformRuby.client.make_request(create_member_options)
-
-      member_params = response['member']
-      ::MXPlatformRuby::Member.new(member_params)
-    end
-
-    def self.delete_member(options = {})
-      delete_member_options = delete_member_options(options)
-      ::MXPlatformRuby.client.make_request(delete_member_options)
-    end
-
-    def self.extend_history(options = {})
-      extend_history_options = extend_history_options(options)
-      response = ::MXPlatformRuby.client.make_request(extend_history_options)
-
-      member_params = response['member']
-      ::MXPlatformRuby::Member.new(member_params)
-    end
-
-    def self.fetch_statements_by_member(options = {})
-      fetch_statements_by_member_options = fetch_statements_by_member_options(options)
-      response = ::MXPlatformRuby.client.make_request(fetch_statements_by_member_options)
-
-      member_params = response['member']
-      ::MXPlatformRuby::Member.new(member_params)
-    end
-
-    def self.identify_member(options = {})
-      identify_member_options = identify_member_options(options)
-      response = ::MXPlatformRuby.client.make_request(identify_member_options)
-
-      member_params = response['member']
-      ::MXPlatformRuby::Member.new(member_params)
-    end
-
-    def self.list_members(options = {})
-      options = list_members_options(options)
-
-      paginate(options)
-    end
-
-    def self.read_member(options = {})
-      read_member_options = read_member_options(options)
-      response = ::MXPlatformRuby.client.make_request(read_member_options)
-
-      member_params = response['member']
-      ::MXPlatformRuby::Member.new(member_params)
-    end
-
-    def self.resume_aggregation(options = {})
-      resume_aggregation_options = resume_aggregation_options(options)
-      response = ::MXPlatformRuby.client.make_request(resume_aggregation_options)
-
-      member_params = response['member']
-      ::MXPlatformRuby::Member.new(member_params)
-    end
-
-    def self.update_member(options = {})
-      update_member_options = update_member_options(options)
-      response = ::MXPlatformRuby.client.make_request(update_member_options)
-
-      member_params = response['member']
-      ::MXPlatformRuby::Member.new(member_params)
-    end
-
-    def self.verify_member(options = {})
-      verify_member_options = verify_member_options(options)
-      response = ::MXPlatformRuby.client.make_request(verify_member_options)
-
-      member_params = response['member']
-      ::MXPlatformRuby::Member.new(member_params)
-    end
-
-    # Private class methods
-
-    def self.aggregate_member_options(options)
-      {
-        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}/aggregate",
-        http_method: :post
-      }
-    end
-    private_class_method :aggregate_member_options
-
-    def self.check_balances_options(options)
-      {
-        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}/check_balance",
-        http_method: :post
-      }
-    end
-    private_class_method :check_balances_options
-
-    def self.create_member_options(options)
-      {
-        endpoint: "/users/#{options[:user_guid]}/members",
-        http_method: :post,
-        request_body: {
-          member: {
-            background_aggregation_is_disabled: options[:background_aggregation_is_disabled],
-            credentials: options[:credentials],
-            id: options[:id],
-            institution_code: options[:institution_code],
-            is_oauth: options[:is_oauth],
-            metadata: options[:metadata],
-            skip_aggregation: options[:skip_aggregation]
-          }.compact,
-          referral_source: options[:referral_source],
-          ui_message_webview_url_scheme: options[:ui_message_webview_url_scheme]
-        }.compact
-      }
-    end
-    private_class_method :create_member_options
-
-    def self.delete_member_options(options)
-      {
-        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}",
-        http_method: :delete
-      }
-    end
-    private_class_method :delete_member_options
-
-    def self.extend_history_options(options)
-      {
-        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}/extend_history",
-        http_method: :post
-      }
-    end
-    private_class_method :extend_history_options
-
-    def self.fetch_statements_by_member_options(options)
-      {
-        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}/fetch_statements",
-        http_method: :post
-      }
-    end
-    private_class_method :fetch_statements_by_member_options
-
-    def self.identify_member_options(options)
-      {
-        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}/identify",
-        http_method: :post
-      }
-    end
-    private_class_method :identify_member_options
-
-    def self.list_members_options(options)
-      {
-        endpoint: "/users/#{options[:user_guid]}/members",
-        http_method: :get,
-        query_params: {
-          page: options[:page],
-          records_per_page: options[:records_per_page]
-        }.compact,
-        resource: 'members'
-      }
-    end
-    private_class_method :list_members_options
-
-    def self.read_member_options(options)
-      {
-        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}",
-        http_method: :get
-      }
-    end
-    private_class_method :read_member_options
-
-    def self.resume_aggregation_options(options)
-      {
-        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}/resume",
-        http_method: :put,
-        request_body: {
-          member: {
-            challenges: options[:challenges]
-          }.compact
-        }
-      }
-    end
-    private_class_method :resume_aggregation_options
-
-    def self.update_member_options(options)
-      {
-        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}",
-        http_method: :put,
-        request_body: {
-          member: {
-            background_aggregation_is_disabled: options[:background_aggregation_is_disabled],
-            credentials: options[:credentials],
-            id: options[:id],
-            metadata: options[:metadata],
-            skip_aggregation: options[:skip_aggregation]
-          }.compact
-        }
-      }
-    end
-    private_class_method :update_member_options
-
-    def self.verify_member_options(options)
-      {
-        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}/verify",
-        http_method: :post
-      }
-    end
-    private_class_method :verify_member_options
-  end
-end