mx-platform-ruby 0.1.0 → 0.1.1

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

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

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

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module MXPlatformRuby
+  class MemberStatus
+    include ::ActiveAttr::Model
+
+    attribute :aggregated_at
+    attribute :challenges
+    attribute :connection_status
+    attribute :guid
+    attribute :has_processed_accounts
+    attribute :has_processed_transactions
+    attribute :is_authenticated
+    attribute :is_being_aggregated
+    attribute :successfully_aggregated_at
+
+    def self.read_member_status(options = {})
+      read_member_status_options = read_member_status_options(options)
+      response = ::MXPlatformRuby.client.make_request(read_member_status_options)
+
+      member_params = response['member']
+      ::MXPlatformRuby::MemberStatus.new(member_params)
+    end
+
+    # Private class methods
+
+    def self.read_member_status_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}/status",
+        http_method: :get
+      }
+    end
+    private_class_method :read_member_status_options
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module MXPlatformRuby
+  class Merchant
+    extend ::MXPlatformRuby::Pageable
+    include ::ActiveAttr::Model
+
+    attribute :created_at
+    attribute :guid
+    attribute :logo_url
+    attribute :name
+    attribute :updated_at
+    attribute :website_url
+
+    def self.list_merchants(options = {})
+      options = list_merchants_options(options)
+
+      paginate(options)
+    end
+
+    def self.read_merchant(options = {})
+      read_merchant_options = read_merchant_options(options)
+      response = ::MXPlatformRuby.client.make_request(read_merchant_options)
+
+      merchant_params = response['merchant']
+      ::MXPlatformRuby::Merchant.new(merchant_params)
+    end
+
+    # Private class methods
+
+    def self.list_merchants_options(options)
+      {
+        endpoint: '/merchants',
+        http_method: :get,
+        query_params: {
+          page: options[:page],
+          records_per_page: options[:records_per_page]
+        }.compact,
+        resource: 'merchants'
+      }
+    end
+    private_class_method :list_merchants_options
+
+    def self.read_merchant_options(options)
+      {
+        endpoint: "/merchants/#{options[:merchant_guid]}",
+        http_method: :get
+      }
+    end
+    private_class_method :read_merchant_options
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module MXPlatformRuby
+  class OAuthWindow
+    include ::ActiveAttr::Model
+
+    attribute :guid
+    attribute :oauth_window_uri
+
+    def self.request_oauth_window(options = {})
+      request_oauth_window_options = request_oauth_window_options(options)
+      response = ::MXPlatformRuby.client.make_request(request_oauth_window_options)
+
+      member_params = response['member']
+      ::MXPlatformRuby::OAuthWindow.new(member_params)
+    end
+
+    # Private class methods
+
+    def self.request_oauth_window_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}/oauth_window_uri",
+        http_method: :get,
+        query_params: {
+          referral_source: options[:referral_source],
+          ui_message_webview_url_scheme: options[:ui_message_webview_url_scheme]
+        }.compact
+      }
+    end
+    private_class_method :request_oauth_window_options
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module MXPlatformRuby
+  class Page < ::Array
+    attr_accessor :current_page, :per_page, :total_entries, :total_pages
+  end
+
+  module Pageable
+    def paginate(options = {})
+      klass = options.fetch(:klass, self)
+      resource = options.fetch(:resource)
+
+      response = ::MXPlatformRuby.client.make_request(options)
+      return nil if response.nil?
+
+      pagination = response['pagination']
+
+      records = response[resource].map { |attributes| klass.new(attributes) }
+
+      page = ::MXPlatformRuby::Page.new(records)
+      page.current_page = pagination['current_page']
+      page.per_page = pagination['per_page']
+      page.total_entries = pagination['total_entries']
+      page.total_pages = pagination['total_pages']
+
+      page
+    end
+  end
+end