mx-platform-ruby 0.1.0 → 0.1.1

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module MXPlatformRuby
+  class Statement
+    extend ::MXPlatformRuby::Pageable
+    include ::ActiveAttr::Model
+
+    attribute :account_guid
+    attribute :content_hash
+    attribute :created_at
+    attribute :guid
+    attribute :member_guid
+    attribute :updated_at
+    attribute :uri
+    attribute :user_guid
+
+    def self.download_statement_pdf(options = {})
+      download_statement_pdf_options = download_statement_pdf_options(options)
+      ::MXPlatformRuby.client.make_request(download_statement_pdf_options)
+    end
+
+    def self.list_statements_by_member(options = {})
+      options = list_statements_by_member_options(options)
+
+      paginate(options)
+    end
+
+    def self.read_statement_by_member(options = {})
+      read_statement_by_member_options = read_statement_by_member_options(options)
+      response = ::MXPlatformRuby.client.make_request(read_statement_by_member_options)
+
+      statement_params = response['statement']
+      ::MXPlatformRuby::Statement.new(statement_params)
+    end
+
+    # Private class methods
+
+    def self.download_statement_pdf_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}/statements/#{options[:statement_guid]}.pdf",
+        headers: {
+          'Accept': 'application/vnd.mx.api.v1+pdf'
+        },
+        http_method: :get
+      }
+    end
+    private_class_method :download_statement_pdf_options
+
+    def self.list_statements_by_member_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}/statements",
+        http_method: :get,
+        query_params: {
+          page: options[:page],
+          records_per_page: options[:records_per_page]
+        }.compact,
+        resource: 'statements'
+      }
+    end
+    private_class_method :list_statements_by_member_options
+
+    def self.read_statement_by_member_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}/statements/#{options[:statement_guid]}",
+        http_method: :get
+      }
+    end
+    private_class_method :read_statement_by_member_options
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module MXPlatformRuby
+  class Tag
+    extend ::MXPlatformRuby::Pageable
+    include ::ActiveAttr::Model
+
+    attribute :guid
+    attribute :name
+    attribute :user_guid
+
+    def self.create_tag(options = {})
+      create_tag_options = create_tag_options(options)
+      response = ::MXPlatformRuby.client.make_request(create_tag_options)
+
+      tag_params = response['tag']
+      ::MXPlatformRuby::Tag.new(tag_params)
+    end
+
+    def self.delete_tag(options = {})
+      delete_tag_options = delete_tag_options(options)
+      ::MXPlatformRuby.client.make_request(delete_tag_options)
+    end
+
+    def self.list_tags(options = {})
+      options = list_tags_options(options)
+
+      paginate(options)
+    end
+
+    def self.read_tag(options = {})
+      read_tag_options = read_tag_options(options)
+      response = ::MXPlatformRuby.client.make_request(read_tag_options)
+
+      tag_params = response['tag']
+      ::MXPlatformRuby::Tag.new(tag_params)
+    end
+
+    def self.update_tag(options = {})
+      update_tag_options = update_tag_options(options)
+      response = ::MXPlatformRuby.client.make_request(update_tag_options)
+
+      tag_params = response['tag']
+      ::MXPlatformRuby::Tag.new(tag_params)
+    end
+
+    # Private class methods
+
+    def self.create_tag_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/tags",
+        http_method: :post,
+        request_body: {
+          tag: {
+            name: options[:name]
+          }.compact
+        }
+      }
+    end
+    private_class_method :create_tag_options
+
+    def self.delete_tag_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/tags/#{options[:tag_guid]}",
+        http_method: :delete
+      }
+    end
+    private_class_method :delete_tag_options
+
+    def self.list_tags_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/tags",
+        http_method: :get,
+        query_params: {
+          page: options[:page],
+          records_per_page: options[:records_per_page]
+        }.compact,
+        resource: 'tags'
+      }
+    end
+    private_class_method :list_tags_options
+
+    def self.read_tag_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/tags/#{options[:tag_guid]}",
+        http_method: :get
+      }
+    end
+    private_class_method :read_tag_options
+
+    def self.update_tag_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/tags/#{options[:tag_guid]}",
+        http_method: :put,
+        request_body: {
+          tag: {
+            name: options[:name]
+          }.compact
+        }
+      }
+    end
+    private_class_method :update_tag_options
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module MXPlatformRuby
+  class Tagging
+    extend ::MXPlatformRuby::Pageable
+    include ::ActiveAttr::Model
+
+    attribute :guid
+    attribute :member_is_managed_by_user
+    attribute :tag_guid
+    attribute :transaction_guid
+    attribute :user_guid
+
+    def self.create_tagging(options = {})
+      create_tagging_options = create_tagging_options(options)
+      response = ::MXPlatformRuby.client.make_request(create_tagging_options)
+
+      tagging_params = response['tagging']
+      ::MXPlatformRuby::Tagging.new(tagging_params)
+    end
+
+    def self.delete_tagging(options = {})
+      delete_tagging_options = delete_tagging_options(options)
+      ::MXPlatformRuby.client.make_request(delete_tagging_options)
+    end
+
+    def self.list_taggings(options = {})
+      options = list_taggings_options(options)
+
+      paginate(options)
+    end
+
+    def self.read_tagging(options = {})
+      read_tagging_options = read_tagging_options(options)
+      response = ::MXPlatformRuby.client.make_request(read_tagging_options)
+
+      tagging_params = response['tagging']
+      ::MXPlatformRuby::Tagging.new(tagging_params)
+    end
+
+    def self.update_tagging(options = {})
+      update_tagging_options = update_tagging_options(options)
+      response = ::MXPlatformRuby.client.make_request(update_tagging_options)
+
+      tagging_params = response['tagging']
+      ::MXPlatformRuby::Tagging.new(tagging_params)
+    end
+
+    # Private class methods
+
+    def self.create_tagging_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/taggings",
+        http_method: :post,
+        request_body: {
+          tagging: {
+            tag_guid: options[:tag_guid],
+            transaction_guid: options[:transaction_guid]
+          }.compact
+        }
+      }
+    end
+    private_class_method :create_tagging_options
+
+    def self.delete_tagging_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/taggings/#{options[:tagging_guid]}",
+        http_method: :delete
+      }
+    end
+    private_class_method :delete_tagging_options
+
+    def self.list_taggings_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/taggings",
+        http_method: :get,
+        query_params: {
+          page: options[:page],
+          records_per_page: options[:records_per_page]
+        }.compact,
+        resource: 'taggings'
+      }
+    end
+    private_class_method :list_taggings_options
+
+    def self.read_tagging_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/taggings/#{options[:tagging_guid]}",
+        http_method: :get
+      }
+    end
+    private_class_method :read_tagging_options
+
+    def self.update_tagging_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/taggings/#{options[:tagging_guid]}",
+        http_method: :put,
+        request_body: {
+          tagging: {
+            tag_guid: options[:tag_guid]
+          }.compact
+        }
+      }
+    end
+    private_class_method :update_tagging_options
+  end
+end

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

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module MXPlatformRuby
+  class Transaction
+    extend ::MXPlatformRuby::Pageable
+    include ::ActiveAttr::Model
+
+    attribute :account_guid
+    attribute :amount
+    attribute :category
+    attribute :check_number_string
+    attribute :created_at
+    attribute :currency_code
+    attribute :date
+    attribute :description
+    attribute :guid
+    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 :is_recurring
+    attribute :is_subscription
+    attribute :latitude
+    attribute :localized_description
+    attribute :localized_memo
+    attribute :longitude
+    attribute :member_guid
+    attribute :memo
+    attribute :merchant_category_code
+    attribute :merchant_guid
+    attribute :original_description
+    attribute :posted_at
+    attribute :status
+    attribute :top_level_category
+    attribute :transacted_at
+    attribute :type
+    attribute :updated_at
+    attribute :user_guid
+
+    def self.list_transactions_by_account(options = {})
+      options = list_transactions_by_account_options(options)
+
+      paginate(options)
+    end
+
+    def self.list_transactions_by_member(options = {})
+      options = list_transactions_by_member_options(options)
+
+      paginate(options)
+    end
+
+    def self.list_transactions_by_tag(options = {})
+      options = list_transactions_by_tag_options(options)
+
+      paginate(options)
+    end
+
+    def self.list_transactions_by_user(options = {})
+      options = list_transactions_by_user_options(options)
+
+      paginate(options)
+    end
+
+    def self.read_transaction(options = {})
+      read_transaction_options = read_transaction_options(options)
+      response = ::MXPlatformRuby.client.make_request(read_transaction_options)
+
+      transaction_params = response['transaction']
+      ::MXPlatformRuby::Transaction.new(transaction_params)
+    end
+
+    def self.update_transaction(options = {})
+      update_transaction_options = update_transaction_options(options)
+      response = ::MXPlatformRuby.client.make_request(update_transaction_options)
+
+      transaction_params = response['transaction']
+      ::MXPlatformRuby::Transaction.new(transaction_params)
+    end
+
+    # Private class methods
+
+    def self.list_transactions_by_account_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/accounts/#{options[:account_guid]}/transactions",
+        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: 'transactions'
+      }
+    end
+    private_class_method :list_transactions_by_account_options
+
+    def self.list_transactions_by_member_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/members/#{options[:member_guid]}/transactions",
+        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: 'transactions'
+      }
+    end
+    private_class_method :list_transactions_by_member_options
+
+    def self.list_transactions_by_tag_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/tags/#{options[:tag_guid]}/transactions",
+        http_method: :get,
+        resource: 'transactions'
+      }
+    end
+    private_class_method :list_transactions_by_tag_options
+
+    def self.list_transactions_by_user_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/transactions",
+        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: 'transactions'
+      }
+    end
+    private_class_method :list_transactions_by_user_options
+
+    def self.read_transaction_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/transactions/#{options[:transaction_guid]}",
+        http_method: :get
+      }
+    end
+    private_class_method :read_transaction_options
+
+    def self.update_transaction_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/transactions/#{options[:transaction_guid]}",
+        http_method: :put,
+        request_body: {
+          transaction: {
+            description: options[:description]
+          }.compact
+        }
+      }
+    end
+    private_class_method :update_transaction_options
+  end
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module MXPlatformRuby
+  class TransactionRule
+    extend ::MXPlatformRuby::Pageable
+    include ::ActiveAttr::Model
+
+    attribute :category_guid
+    attribute :created_at
+    attribute :description
+    attribute :guid
+    attribute :match_description
+    attribute :updated_at
+    attribute :user_guid
+
+    def self.create_transaction_rule(options = {})
+      create_transaction_rule_options = create_transaction_rule_options(options)
+      response = ::MXPlatformRuby.client.make_request(create_transaction_rule_options)
+
+      transaction_rule_params = response['transaction_rule']
+      ::MXPlatformRuby::TransactionRule.new(transaction_rule_params)
+    end
+
+    def self.delete_transaction_rule(options = {})
+      delete_transaction_rule_options = delete_transaction_rule_options(options)
+      ::MXPlatformRuby.client.make_request(delete_transaction_rule_options)
+    end
+
+    def self.list_transaction_rules_by_user(options = {})
+      options = list_transaction_rules_by_user_options(options)
+
+      paginate(options)
+    end
+
+    def self.read_transaction_rule(options = {})
+      read_transaction_rule_options = read_transaction_rule_options(options)
+      response = ::MXPlatformRuby.client.make_request(read_transaction_rule_options)
+
+      transaction_rule_params = response['transaction_rule']
+      ::MXPlatformRuby::TransactionRule.new(transaction_rule_params)
+    end
+
+    def self.update_transaction_rule(options = {})
+      update_transaction_rule_options = update_transaction_rule_options(options)
+      response = ::MXPlatformRuby.client.make_request(update_transaction_rule_options)
+
+      transaction_rule_params = response['transaction_rule']
+      ::MXPlatformRuby::TransactionRule.new(transaction_rule_params)
+    end
+
+    # Private class methods
+
+    def self.create_transaction_rule_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/transaction_rules",
+        http_method: :post,
+        request_body: {
+          transaction_rule: {
+            category_guid: options[:category_guid],
+            description: options[:description],
+            match_description: options[:match_description]
+          }.compact
+        }
+      }
+    end
+    private_class_method :create_transaction_rule_options
+
+    def self.delete_transaction_rule_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/transaction_rules/#{options[:transaction_rule_guid]}",
+        http_method: :delete
+      }
+    end
+    private_class_method :delete_transaction_rule_options
+
+    def self.list_transaction_rules_by_user_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/transaction_rules",
+        http_method: :get,
+        query_params: {
+          page: options[:page],
+          records_per_page: options[:records_per_page]
+        }.compact,
+        resource: 'transaction_rules'
+      }
+    end
+    private_class_method :list_transaction_rules_by_user_options
+
+    def self.read_transaction_rule_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/transaction_rules/#{options[:transaction_rule_guid]}",
+        http_method: :get
+      }
+    end
+    private_class_method :read_transaction_rule_options
+
+    def self.update_transaction_rule_options(options)
+      {
+        endpoint: "/users/#{options[:user_guid]}/transaction_rules/#{options[:transaction_rule_guid]}",
+        http_method: :put,
+        request_body: {
+          transaction_rule: {
+            category_guid: options[:category_guid],
+            description: options[:description],
+            match_description: options[:match_description]
+          }.compact
+        }
+      }
+    end
+    private_class_method :update_transaction_rule_options
+  end
+end