revolut-api 0.1.0

data/lib/revolut/api/private/transactions.rb

@@ -0,0 +1,77 @@
+module Revolut
+  module Api
+    module Private
+      module Transactions
+      
+        def transactions(from: Time.new(Time.now.year, Time.now.month, 1, 0, 0, 0, 0), type: nil, phrase: nil, completed: nil, pending: nil, fetch_all: true, memoize: true)
+          current                     =   Time.now.utc
+          txs                         =   {}
+      
+          if fetch_all && memoize && memoized.fetch(:transactions, []).any?
+            txs                       =   memoized.fetch(:transactions, [])
+          else
+            while from < current
+              params                  =   {from: ::Revolut::Api::Utilities.utc_to_epoch(from)}
+              data                    =   request_transactions(params: params)
+        
+              data.each do |item|
+                tx                    =   ::Revolut::Api::Response::Transaction.new(item)
+                txs[tx.id]            =   tx if tx && !tx.id.to_s.empty?
+              end
+        
+              from                    =   from + ::Revolut::Api::Constants::TIME[:one_month]
+              break unless fetch_all
+            end
+      
+            txs                       =   txs.values
+            memoized[:transactions]   =   txs if fetch_all
+          end
+      
+          if !type.to_s.empty?
+            txs                       =   txs.select { |tx| tx.type.to_s.upcase.strip == type.to_s.upcase.strip }
+          end
+      
+          if completed.eql?(true)
+            txs                       =   txs.select { |tx| tx.completed? }
+          end
+          
+          if pending.eql?(true)
+            txs                       =   txs.select { |tx| tx.pending? }
+          end
+      
+          if !phrase.to_s.empty?
+            txs                       =   txs.select { |tx| !(tx.description =~ /#{phrase}/i).nil? }
+          end
+      
+          txs                         =   txs.sort_by { |tx| tx.started_date }
+      
+          return txs
+        end
+    
+        def request_transactions(params: {}, retries: 3)
+          data                        =   nil
+      
+          begin
+            data                      =   get("user/current/transactions", params: params)
+          rescue Faraday::ParsingError => e
+            retries        -=   1
+            retry if retries > 0
+          end
+      
+          return data
+        end
+    
+        def transaction(id)
+          response          =   get("transaction/#{id}")
+      
+          if response.is_a?(Hash)
+            log "#{response["message"]}"
+          elsif response.is_a?(Array)
+            return ::Revolut::Api::Response::Transaction.new(response&.first)
+          end
+        end
+      
+      end
+    end
+  end
+end

data/lib/revolut/api/private/user.rb

@@ -0,0 +1,40 @@
+module Revolut
+  module Api
+    module Private
+      module User
+      
+        def user
+          ::Revolut::Api::Response::User.new(get("user/current"))
+        end
+      
+        def wallet
+          ::Revolut::Api::Response::Wallet.new(get("user/current/wallet"))
+        end
+    
+        def cards
+          get("user/current/cards")&.collect { |response| ::Revolut::Api::Response::Card.new(response) }
+        end
+      
+        def update_address(city: nil, country: nil, postcode: nil, region: nil, street_line_one: nil, street_line_two: nil)
+          response                    =   nil
+          address                     =   user.address
+      
+          if address
+            address.city              =   city            unless city.nil?
+            address.country           =   country         unless country.nil?
+            address.postcode          =   postcode        unless postcode.nil?
+            address.region            =   region          unless region.nil?
+            address.street_line_one   =   street_line_one unless street_line_one.nil?
+            address.street_line_two   =   street_line_two unless street_line_two.nil?
+      
+            payload                   =   {"address" => address.to_api_hash}      
+            response                  =   patch("user/current", data: payload)
+          end
+          
+          return response
+        end
+      
+      end
+    end
+  end
+end

data/lib/revolut/api/public/client.rb

@@ -0,0 +1,24 @@
+module Revolut
+  module Api
+    module Public
+    
+      class Client < ::Revolut::Api::Base
+        def initialize(host: "www.revolut.com")
+          super(host: host)
+        end
+    
+        def quotes(from: [], to: [], endpoint: "api/quote/internal")
+          options     =   {
+            user_agent:           ::Revolut::Api::Constants::PUBLIC_USER_AGENT,
+            authenticate:         false,
+            check_configuration:  false
+          }
+          
+          super(from: from, to: to, endpoint: endpoint, options: options)
+        end
+    
+      end
+    
+    end
+  end
+end

data/lib/revolut/api/railtie.rb

@@ -0,0 +1,14 @@
+require 'revolut'
+require 'rails'
+
+module Revolut
+  module Api
+    class Railtie < Rails::Railtie
+    
+      #rake_tasks do
+      #  Dir[File.join(File.dirname(__FILE__), '../tasks/*.rake')].each { |ext| load ext }
+      #end
+    
+    end
+  end
+end

data/lib/revolut/api/response/address.rb

@@ -0,0 +1,36 @@
+module Revolut
+  module Api
+    module Response
+      class Address
+        attr_accessor :mapping
+        attr_accessor :country, :city, :postcode, :region, :street_line_one, :street_line_two
+      
+        MAPPING                 =   {
+          "country"       =>  :country,
+          "city"          =>  :city,
+          "postcode"      =>  :postcode,
+          "region"        =>  :region,
+          "streetLine1"   =>  :street_line_one,
+          "streetLine2"   =>  :street_line_two
+        }
+      
+        def initialize(hash = {})
+          ::Revolut::Api::Response::Address::MAPPING.each do |revolut_key, accessor|
+            self.send("#{accessor}=", hash.fetch(revolut_key, nil))
+          end
+        end
+      
+        def to_api_hash
+          hash                  =   {}
+        
+          ::Revolut::Api::Response::Address::MAPPING.each do |revolut_key, accessor|
+            hash[revolut_key]   =   self.send(accessor)
+          end
+        
+          return hash
+        end
+      
+      end
+    end
+  end
+end

data/lib/revolut/api/response/card.rb

@@ -0,0 +1,54 @@
+module Revolut
+  module Api
+    module Response
+      class Card
+        attr_accessor :id, :owner_id
+        attr_accessor :last_four, :brand
+        attr_accessor :expiry_date, :expired
+        attr_accessor :three_d_verified, :address, :issuer
+        attr_accessor :currency, :confirmed, :confirmation_attempts, :auto_topup
+        attr_accessor :created_date, :updated_date, :last_used_date
+        attr_accessor :topup_limit, :current_topup
+      
+        def initialize(hash = {})
+          self.id                       =   hash.fetch("id", nil)
+          self.owner_id                 =   hash.fetch("ownerId", nil)
+          self.last_four                =   hash.fetch("lastFour", nil)&.to_i
+          self.brand                    =   hash.fetch("brand", nil)
+        
+          self.expiry_date              =   {
+            month: hash.fetch("expiryDate", {}).fetch("month", nil),
+            year:  hash.fetch("expiryDate", {}).fetch("year", nil),
+          }
+        
+          self.three_d_verified         =   hash.fetch("threeDVerified", false)
+        
+          address_data                  =   hash.fetch("address", {})
+          self.address                  =   ::Revolut::Api::Response::Address.new(address_data)
+        
+          issuer_data                   =   hash.fetch("issuer", {})
+          self.issuer                   =   ::Revolut::Api::Response::CardIssuer.new(issuer_data)
+        
+          self.currency                 =   hash.fetch("currency", nil)
+          self.confirmed                =   hash.fetch("confirmed", false)
+          self.confirmation_attempts    =   hash.fetch("confirmationAttempts", 0)
+          self.auto_topup               =   hash.fetch("autoTopup", nil)
+        
+          self.created_date             =   hash.fetch("createdDate", nil)
+          self.created_date             =   ::Revolut::Api::Utilities.epoch_to_utc(self.created_date) unless self.created_date.nil?
+          self.updated_date             =   hash.fetch("updatedDate", nil)
+          self.updated_date             =   ::Revolut::Api::Utilities.epoch_to_utc(self.updated_date) unless self.updated_date.nil?
+          self.last_used_date           =   hash.fetch("lastUsedDate", nil)
+          self.last_used_date           =   ::Revolut::Api::Utilities.epoch_to_utc(self.last_used_date) unless self.last_used_date.nil?
+        
+          self.topup_limit              =   hash.fetch("topupLimit", nil)
+          self.topup_limit              =   ::Revolut::Api::Utilities.convert_from_integer_amount(self.currency, self.topup_limit) if !self.currency.to_s.empty? && !self.topup_limit.nil?
+        
+          self.current_topup            =   hash.fetch("currentTopup", nil)
+          self.current_topup            =   ::Revolut::Api::Utilities.convert_from_integer_amount(self.currency, self.current_topup) if !self.currency.to_s.empty? && !self.current_topup.nil?
+        end
+      
+      end
+    end
+  end
+end

data/lib/revolut/api/response/card_issuer.rb

@@ -0,0 +1,29 @@
+module Revolut
+  module Api
+    module Response
+      class CardIssuer
+        attr_accessor :mapping
+        attr_accessor :bin, :name, :logo_url
+        attr_accessor :card_type, :card_brand
+        attr_accessor :currency, :supported
+      
+        MAPPING   =   {
+          "bin"         =>  :bin,
+          "name"        =>  :name,
+          "logoUrl"     =>  :logo_url,
+          "cardType"    =>  :card_type,
+          "cardBrand"   =>  :card_brand,
+          "currency"    =>  :currency,
+          "supported"   =>  :supported
+        }
+      
+        def initialize(hash = {})
+          ::Revolut::Api::Response::CardIssuer::MAPPING.each do |revolut_key, accessor|
+            self.send("#{accessor}=", hash.fetch(revolut_key, nil))
+          end
+        end
+      
+      end
+    end
+  end
+end

data/lib/revolut/api/response/merchant.rb

@@ -0,0 +1,30 @@
+module Revolut
+  module Api
+    module Response
+      class Merchant
+        attr_accessor :mapping
+        attr_accessor :id, :scheme, :name, :mcc, :country, :state, :city, :postcode, :address, :category
+      
+        MAPPING                 =   {
+          "id"            =>  :id,
+          "scheme"        =>  :scheme,
+          "name"          =>  :name,
+          "mcc"           =>  :mcc,
+          "country"       =>  :country,
+          "state"         =>  :state,
+          "city"          =>  :city,
+          "postcode"      =>  :postcode,
+          "address"       =>  :address,
+          "category"      =>  :category,
+        }
+      
+        def initialize(hash = {})
+          ::Revolut::Api::Response::Merchant::MAPPING.each do |revolut_key, accessor|
+            self.send("#{accessor}=", hash.fetch(revolut_key, nil))
+          end
+        end
+      
+      end
+    end
+  end
+end

data/lib/revolut/api/response/pocket.rb

@@ -0,0 +1,33 @@
+module Revolut
+  module Api
+    module Response
+      class Pocket
+        attr_accessor :id, :state
+        attr_accessor :currency
+        attr_accessor :balance, :blocked_amount
+      
+        def initialize(hash = {})
+          self.id               =   hash.fetch("id", nil)
+          self.state            =   hash.fetch("state", nil)
+        
+          self.currency         =   hash.fetch("currency", nil)
+        
+          self.balance          =   hash.fetch("balance", nil)
+          self.balance          =   ::Revolut::Api::Utilities.convert_from_integer_amount(self.currency, self.balance) if !self.currency.to_s.empty? && !self.balance.nil?
+        
+          self.blocked_amount   =   hash.fetch("blockedAmount", nil)
+          self.blocked_amount   =   ::Revolut::Api::Utilities.convert_from_integer_amount(self.currency, self.blocked_amount) if !self.currency.to_s.empty? && !self.blocked_amount.nil?
+        end
+      
+        def active?
+          in_state?(:active)
+        end
+      
+        def in_state?(state)
+          self.state.downcase.strip.to_sym.eql?(state)
+        end
+      
+      end
+    end
+  end
+end

data/lib/revolut/api/response/quote.rb

@@ -0,0 +1,52 @@
+module Revolut
+  module Api
+    module Response
+      class Quote
+        attr_accessor :from, :to
+        attr_accessor :fee, :rate, :markup
+        attr_accessor :epoch, :timestamp
+        attr_accessor :success, :message
+      
+        def initialize(hash = {})
+          if hash.has_key?("message")
+            self.message                  =   hash.fetch("message")
+            self.success                  =   false
+        
+          else
+            self.from                     =   {}
+            self.to                       =   {}
+            self.fee                      =   {}
+        
+            set_amount_hash("from", hash)
+            set_amount_hash("to", hash)
+            set_amount_hash("fee", hash)
+        
+            self.rate                     =   hash.fetch("rate", nil)
+            self.markup                   =   hash.fetch("markup", nil)
+        
+            self.epoch                    =   hash.fetch("timestamp", nil)
+            self.timestamp                =   ::Revolut::Api::Utilities.epoch_to_utc(self.epoch)
+          
+            self.success                  =   true
+          end
+        end
+      
+        def set_amount_hash(key, hash)
+          if hash.has_key?(key)
+            sub_item                      =   hash.fetch(key, {})
+          
+            if sub_item.is_a?(Hash)
+              self.send(key)[:currency]     =   sub_item.fetch("currency", nil)
+              self.send(key)[:base_amount]  =   sub_item.fetch("amount", nil)
+              self.send(key)[:amount]       =   ::Revolut::Api::Utilities.convert_from_integer_amount(self.send(key)[:currency], self.send(key)[:base_amount]) if !self.send(key)[:currency].to_s.empty? && !self.send(key)[:base_amount].nil?
+          
+            elsif sub_item.is_a?(String)
+              self.send("#{key}=", sub_item)
+            end
+          end
+        end
+      
+      end
+    end
+  end
+end

data/lib/revolut/api/response/transaction.rb

@@ -0,0 +1,67 @@
+module Revolut
+  module Api
+    module Response
+      class Transaction
+        attr_accessor :id, :leg_id
+        attr_accessor :type, :state
+        attr_accessor :started_date, :updated_date, :completed_date
+        attr_accessor :currency, :amount, :fee, :balance, :description, :rate
+        attr_accessor :direction, :counterpart
+        attr_accessor :merchant, :card
+      
+        def initialize(hash = {})
+          self.id                       =   hash.fetch("id", nil)
+          self.leg_id                   =   hash.fetch("legId", nil)
+          self.type                     =   hash.fetch("type", nil)
+          self.state                    =   hash.fetch("state", nil)
+        
+          self.started_date             =   hash.fetch("startedDate", nil)
+          self.started_date             =   ::Revolut::Api::Utilities.epoch_to_utc(self.started_date) unless self.started_date.nil?
+          self.updated_date             =   hash.fetch("updatedDate", nil)
+          self.updated_date             =   ::Revolut::Api::Utilities.epoch_to_utc(self.updated_date) unless self.updated_date.nil?
+          self.completed_date           =   hash.fetch("completedDate", nil)
+          self.completed_date           =   ::Revolut::Api::Utilities.epoch_to_utc(self.completed_date) unless self.completed_date.nil?
+        
+          self.currency                 =   hash.fetch("currency", nil)
+          self.amount                   =   hash.fetch("amount", nil)
+          self.amount                   =   ::Revolut::Api::Utilities.convert_from_integer_amount(self.currency, self.amount) if !self.currency.to_s.empty? && !self.amount.nil?
+        
+          self.fee                      =   hash.fetch("fee", nil)
+          self.fee                      =   ::Revolut::Api::Utilities.convert_from_integer_amount(self.currency, self.fee) if !self.currency.to_s.empty? && !self.fee.nil?
+        
+          self.balance                  =   hash.fetch("balance", nil)
+          self.balance                  =   ::Revolut::Api::Utilities.convert_from_integer_amount(self.currency, self.balance) if !self.currency.to_s.empty? && !self.balance.nil?
+        
+          self.description              =   hash.fetch("description", nil)
+        
+          self.rate                     =   hash.fetch("rate", nil)
+          self.direction                =   hash.fetch("direction", nil)
+        
+          self.counterpart              =   {}
+          self.counterpart[:currency]   =   hash.fetch("counterpart", {}).fetch("currency", nil)
+          self.counterpart[:amount]     =   hash.fetch("counterpart", {}).fetch("amount", nil)
+          self.counterpart[:amount]     =   ::Revolut::Api::Utilities.convert_from_integer_amount(self.counterpart[:currency], self.counterpart[:amount]) if !self.counterpart[:currency].to_s.empty? && !self.counterpart[:amount].nil?
+        
+          merchant_data                 =   hash.fetch("merchant", {})
+          self.merchant                 =   ::Revolut::Api::Response::Merchant.new(merchant_data) if !merchant_data.empty?
+        
+          self.card                     =   {}
+          self.card[:last_four]         =   hash.fetch("card", {}).fetch("lastFour", nil)
+        end
+      
+        def completed?
+          in_state?(:completed)
+        end
+      
+        def pending?
+          in_state?(:pending)
+        end
+      
+        def in_state?(state)
+          self.state.downcase.strip.to_sym.eql?(state)
+        end
+      
+      end
+    end
+  end
+end