fidor_api 1.0.0 → 2.0.0.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b54522075b55638344cfa24ccf0155f1202ace6e02771d106acc7cb2a61fb02
-  data.tar.gz: 79576683345190411723a279ca082da11b31e0b3a9e4e27673a629400b62a7b7
+  metadata.gz: de8a8afe76c2e2584facd1439e52c087e6d9457119ffd8365ea3bcb2ef418640
+  data.tar.gz: 38d944042a2442defe90265299ec4d14327fa183fa7a2e22e9b5596ca92ecc24
 SHA512:
-  metadata.gz: e1aedf0a0f6639acc507412c32c8cf5f6be1a8f41db492cce017110723fd784e52ce930cbb9be522d3fe8edd932ad811d384a3bc3eab0e42a9d0b7c86d07e0af
-  data.tar.gz: f032507b9ea3508d25be09ec12160bdf420b2eda9df4c5306e0eb62073cca27ee5545649a1572d5f06b248335110f64403ac92bacd8ab66c90e89ebb7af45fd3
+  metadata.gz: 4de4c0de79dfad96ede97a5a15f579459efe9c0a9ef88613a8679728abb69d8fb6b6b1ebe1b0a0f67eb9674369c8d062e9d4d0dee4a64b791aca2a5fb0c272f9
+  data.tar.gz: 927502fe292869143510d492eecfdc013a6955d0d2a4414c8aedff620dba6fd5cfdeb378eb86c8b37c895806f58a146afb2ec9c463e2aec02024451e68bd550b

data/README.md

@@ -1,20 +1,18 @@
 # FidorApi
 
 [![Gem Version](https://badge.fury.io/rb/fidor_api.svg)](https://badge.fury.io/rb/fidor_api)
-[![Build Status](https://travis-ci.org/fidor/fidor_api.svg?branch=master)](https://travis-ci.org/fidor/fidor_api)
-[![Test Coverage](https://codeclimate.com/github/fidor/fidor_api/badges/coverage.svg)](https://codeclimate.com/github/fidor/fidor_api/coverage)
-[![Code Climate](https://codeclimate.com/github/fidor/fidor_api/badges/gpa.svg)](https://codeclimate.com/github/fidor/fidor_api)
+[![Build Status](https://travis-ci.org/fidor/fidor_api.svg?branch=v2)](https://travis-ci.org/fidor/fidor_api)
 
-Simple ruby client for the Fidor Bank REST-API: http://docs.fidor.de
+Ruby client library to work with Fidor APIs.
 
-💡 This branch contains the 0.x.x / 1.x.x versions. For 2.x.x versions see master branch.
+💡 This branch contains the `2.x.x` version. For previous versions see `v1` branch.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'fidor_api'
+gem 'fidor_api', '>= 2'
 ```
 
 And then execute:
@@ -30,15 +28,10 @@ Or install it yourself as:
 ### 0. Configure
 
 ```ruby
-FidorApi.configure do |config|
-  config.oauth_url       = ENV["FIDOR_OAUTH_URL"]
-  config.api_url         = ENV["FIDOR_API_URL"]
-  config.callback_url    = ENV["FIDOR_API_CALLBACK"]
-  config.client_id       = ENV["FIDOR_API_CLIENT_ID"]
-  config.client_secret   = ENV["FIDOR_API_CLIENT_SECRET"]
-  config.htauth_user     = ENV["FIDOR_API_HTAUTH_USER"]
-  config.htauth_password = ENV["FIDOR_API_HTAUTH_PASSWORD"]
-  config.affiliate_uid   = ENV["FIDOR_API_AFFILIATE_UID"]
+client = FidorApi::Client.new do |config|
+  config.environment   = FidorApi::Environment::FidorDE::Sandbox
+  config.client_id     = 'your-client-id'
+  config.client_secret = 'your-client-secret'
 end
 ```
 
@@ -47,60 +40,48 @@ end
 Redirect the user to the authorize URL:
 
 ```ruby
-redirect_to FidorApi::Auth.authorize_url
+redirect_to client.authorize_start(
+  redirect_uri: 'https://localhost:3000/callback'
+)
 ```
 
 Use code passed to the callback URL and fetch the access token:
 
 ```ruby
-session[:api_token] = FidorApi::Auth.fetch_token(params[:code]).to_hash
-```
-
-Renew token after it has expired:
-
-```ruby
-def api_token
-  FidorApi::Token.new session[:api_token] if session[:api_token]
-end
-
-if api_token && !api_token.valid?
-  session[:api_token] = FidorApi::Auth.refresh_token(api_token).to_hash
-end
+session[:api_token] = client.authorize_complete(
+  redirect_uri: 'https://localhost:3000/callback',
+  code:         params[:code]
+)
 ```
 
 ### 2. Fetching data
 
 ```ruby
-FidorApi::Connectivity.access_token = "f859032a6ca0a4abb2be0583b8347937"
+client.token = FidorApi::Token.new(session[:api_token])
 
-user = FidorApi::User.current
-# => FidorApi::User
+user = client.user
+# => FidorApi::Model::User
 
-transactions = FidorApi::Transaction.all
+user = client.transactions
 # => FidorApi::Collection
 
 transaction = transactions.first
-# => FidorApi::Transaction
+# => FidorApi::Model::Transaction
 ```
 
 ### 3. Creating transfers
 
 ```ruby
-FidorApi::Connectivity.access_token = "f859032a6ca0a4abb2be0583b8347937"
+client.token = FidorApi::Token.new(session[:api_token])
 
-transfer = FidorApi::Transfer::Internal.new(
+transfer = client.create_internal_transfer(
   account_id:   875,
-  receiver:     "kycfull@fidor.de",
-  external_uid: "4279762F5",
-  subject:      "Money for you",
+  receiver:     'kycfull@fidor.de',
+  external_uid: '4279762F5',
+  subject:      'Money for you',
   amount:       1000
 )
-# => FidorApi::Transfer::Internal
-
-transfer.save
-# => true
-# or
-# => false and `transfer.errors` containing details
+# => FidorApi::Model::Transfer::Classic::Internal
 ```
 
 ## Development
@@ -113,10 +94,6 @@ To install this gem onto your local machine, run `bundle exec rake install`.
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/fidor/fidor_api.
 
-## Changelog
-
-Have a look at the [CHANGELOG](CHANGELOG.md) for details.
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,6 +1,9 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task :default do
+  system('bundle exec rspec')
+  system('bundle exec rubocop')
+end

data/lib/fidor_api/client/authentication.rb

@@ -0,0 +1,63 @@
+module FidorApi
+  class Client
+    module Authentication
+      attr_accessor :token
+
+      # oAuth2 - Resource Owner Password Grant Flow
+      def login(username:, password:, grant_type: 'password')
+        check_flow_support! :resource_owner_password_credentials
+
+        self.token = oauth_token(
+          grant_type: grant_type,
+          username:   username,
+          password:   password
+        )
+      end
+
+      # oAuth2 - Client Credentials Flow
+      def client_login
+        check_flow_support! :client_credentials
+
+        self.token = oauth_token(grant_type: 'client_credentials')
+      end
+
+      # oAuth2 - Authorization Code Grant Flow - Start
+      def authorize_start(redirect_uri:, state: SecureRandom.hex(8))
+        check_flow_support! :authorization_code
+
+        "#{config.environment.auth_host}/oauth/authorize" \
+          + "?client_id=#{config.client_id}" \
+          + "&redirect_uri=#{CGI.escape(redirect_uri)}" \
+          + "&state=#{state}" \
+          + '&response_type=code'
+      end
+
+      # oAuth2 - Authorization Code Grant Flow - Complete
+      def authorize_complete(redirect_uri:, code:)
+        self.token = oauth_token(
+          grant_type:   'authorization_code',
+          client_id:    config.client_id,
+          redirect_uri: redirect_uri,
+          code:         code
+        )
+      end
+
+      private
+
+      def check_flow_support!(symbol)
+        raise Errors::NotSupported \
+          unless config.environment.auth_methods.include? symbol
+      end
+
+      def oauth_token(**body)
+        response = connection(host: config.environment.auth_host).post(
+          '/oauth/token',
+          body: body,
+          auth: [config.client_id, config.client_secret]
+        )
+
+        Token.new(response.body)
+      end
+    end
+  end
+end

data/lib/fidor_api/client/configuration.rb

@@ -0,0 +1,32 @@
+require 'logger'
+
+module FidorApi
+  class Client
+    class Configuration
+      ATTRIBUTES = %i[
+        environment
+        client_id
+        client_secret
+        logger
+        log_bodies
+        verify_ssl
+      ].freeze
+
+      attr_accessor(*ATTRIBUTES)
+
+      def initialize
+        self.environment = Environment::FidorDE::Sandbox.new
+        self.logger      = Logger.new(STDOUT)
+        self.log_bodies  = true
+        self.verify_ssl  = true
+      end
+
+      def validate!
+        ATTRIBUTES.each do |key|
+          raise "Missing config value for `#{key}`!" \
+            if instance_variable_get("@#{key}").nil?
+        end
+      end
+    end
+  end
+end

data/lib/fidor_api/client/connection.rb

@@ -0,0 +1,56 @@
+module FidorApi
+  class Client
+    class Connection
+      DEFAULT_HEADERS = {
+        'Accept'       => 'application/vnd.fidor.de; version=1,text/json',
+        'Content-Type' => 'application/json'
+      }.freeze
+
+      def initialize(client:, host:)
+        @client = client
+        @host   = host
+      end
+
+      %i[get post put patch delete].each do |method|
+        define_method method do |path, query: nil, body: nil, headers: {}, auth: nil|
+          request(
+            path:    path,
+            method:  method,
+            query:   query,
+            body:    body,
+            headers: DEFAULT_HEADERS.merge(headers),
+            auth:    auth
+          )
+        end
+      end
+
+      private
+
+      attr_accessor :client, :host
+
+      def request(path:, method: :get, query: {}, body: {}, headers: {}, auth: nil) # rubocop:disable Metrics/ParameterLists
+        payload = method == :get ? query : body&.to_json
+
+        response = faraday(auth: auth).public_send(method, path, payload) do |request|
+          request.headers = headers
+        end
+
+        response
+      rescue Faraday::ClientError => e
+        client.config.logger.error e.inspect
+        raise
+      end
+
+      def faraday(auth:) # rubocop:disable Metrics/AbcSize
+        Faraday.new(url: host, ssl: { verify: client.config.verify_ssl }) do |config|
+          config.use Faraday::Request::BasicAuthentication, *auth if auth.is_a? Array
+          config.request :oauth2, client.token.access_token, token_type: :bearer if client.token
+          config.response :logger, client.config.logger, bodies: client.config.log_bodies if client.config.logger
+          config.response :raise_error
+          config.response :json, content_type: /json/
+          config.adapter  Faraday.default_adapter
+        end
+      end
+    end
+  end
+end

data/lib/fidor_api/client/dsl/confirmable_actions.rb

@@ -0,0 +1,19 @@
+module FidorApi
+  class Client
+    module DSL
+      module ConfirmableActions
+        def confirmable_action(id, options = {})
+          fetch(:single, Model::ConfirmableAction, "/confirmable/actions/#{id}", options)
+        end
+
+        def refresh_confirmable_action(id, options = {})
+          update(Model::ConfirmableAction, "/confirmable/actions/#{id}/refresh", id, options)
+        end
+
+        def update_confirmable_action(id, attributes = {})
+          update(Model::ConfirmableAction, "/confirmable/actions/#{id}", id, attributes)
+        end
+      end
+    end
+  end
+end

data/lib/fidor_api/client/dsl/core_data.rb

@@ -0,0 +1,19 @@
+module FidorApi
+  class Client
+    module DSL
+      module CoreData
+        def user(options = {})
+          fetch(:single, Model::User, '/users/current', options)
+        end
+
+        def customers(options = {})
+          fetch(:collection, Model::Customer, '/customers', options)
+        end
+
+        def accounts(options = {})
+          fetch(:collection, Model::Account, '/accounts', options)
+        end
+      end
+    end
+  end
+end

data/lib/fidor_api/client/dsl/messages.rb

@@ -0,0 +1,31 @@
+module FidorApi
+  class Client
+    module DSL
+      module Messages
+        def messages(options = {})
+          fetch(:collection, Model::Message, '/messages', options)
+        end
+
+        def message(id, options = {})
+          fetch(:single, Model::Message, "/messages/#{id}", options)
+        end
+
+        def message_attachment(id)
+          response = connection.get("/messages/#{id}/attachment")
+
+          Model::Message::Attachment.new(
+            type:     response.headers['content-type'],
+            filename: response.headers['content-disposition'][/filename="([^"]+)"/, 1],
+            content:  response.body
+          )
+        end
+
+        def message_content(id)
+          response = connection.get("/messages/#{id}/content")
+
+          Model::Message::Content.new(raw: response.body)
+        end
+      end
+    end
+  end
+end

data/lib/fidor_api/client/dsl/transactions.rb

@@ -0,0 +1,15 @@
+module FidorApi
+  class Client
+    module DSL
+      module Transactions
+        def transactions(options = {})
+          fetch(:collection, Model::Transaction, '/transactions', options)
+        end
+
+        def transaction(id, options = {})
+          fetch(:single, Model::Transaction, "/transactions/#{id}", options)
+        end
+      end
+    end
+  end
+end

data/lib/fidor_api/client/dsl/transfers/classic.rb

@@ -0,0 +1,29 @@
+module FidorApi
+  class Client
+    module DSL
+      module Transfers
+        module Classic
+          def internal_transfers(options = {})
+            check_transfer_support! :classic
+            fetch(:collection, FidorApi::Model::Transfer::Classic::Internal, '/internal_transfers', options)
+          end
+
+          def internal_transfer(id, options = {})
+            check_transfer_support! :classic
+            fetch(:single, FidorApi::Model::Transfer::Classic::Internal, "/internal_transfers/#{id}", options)
+          end
+
+          def new_internal_transfer(attributes = {})
+            check_transfer_support! :classic
+            Model::Transfer::Classic::Internal.new(attributes)
+          end
+
+          def create_internal_transfer(attributes = {})
+            check_transfer_support! :classic
+            create(FidorApi::Model::Transfer::Classic::Internal, '/internal_transfers', attributes)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fidor_api/client/dsl/transfers/generic.rb

@@ -0,0 +1,34 @@
+module FidorApi
+  class Client
+    module DSL
+      module Transfers
+        module Generic
+          def transfers(options = {})
+            check_transfer_support! :generic
+            fetch(:collection, FidorApi::Model::Transfer::Generic, '/transfers', options)
+          end
+
+          def transfer(id, options = {})
+            check_transfer_support! :generic
+            fetch(:single, FidorApi::Model::Transfer::Generic, "/transfers/#{id}", options)
+          end
+
+          def new_transfer(attributes = {})
+            check_transfer_support! :generic
+            Model::Transfer::Generic.new(attributes)
+          end
+
+          def create_transfer(attributes = {})
+            check_transfer_support! :generic
+            create(FidorApi::Model::Transfer::Generic, '/transfers', attributes)
+          end
+
+          def update_transfer(id, attributes = {})
+            check_transfer_support! :generic
+            update(FidorApi::Model::Transfer::Generic, "/transfers/#{id}", id, attributes)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fidor_api/client/dsl/transfers.rb

@@ -0,0 +1,22 @@
+module FidorApi
+  class Client
+    module DSL
+      module Transfers
+        autoload :Classic, 'fidor_api/client/dsl/transfers/classic'
+        autoload :Generic, 'fidor_api/client/dsl/transfers/generic'
+
+        def self.included(klass)
+          klass.include Transfers::Classic
+          klass.include Transfers::Generic
+        end
+
+        private
+
+        def check_transfer_support!(type)
+          raise Errors::NotSupported \
+            unless config.environment.transfers_api == type
+        end
+      end
+    end
+  end
+end

data/lib/fidor_api/client/dsl.rb

@@ -0,0 +1,59 @@
+module FidorApi
+  class Client
+    module DSL
+      autoload :ConfirmableActions, 'fidor_api/client/dsl/confirmable_actions'
+      autoload :CoreData,           'fidor_api/client/dsl/core_data'
+      autoload :Messages,           'fidor_api/client/dsl/messages'
+      autoload :Transfers,          'fidor_api/client/dsl/transfers'
+      autoload :Transactions,       'fidor_api/client/dsl/transactions'
+
+      def self.included(klass)
+        klass.include ConfirmableActions
+        klass.include CoreData
+        klass.include Messages
+        klass.include Transfers
+        klass.include Transactions
+      end
+
+      private
+
+      def fetch(type, klass, endpoint, options)
+        case type
+        when :single
+          klass.new(connection.get(endpoint, query: options).body)
+        when :collection
+          Collection.new(klass: klass, raw: connection.get(endpoint, query: options).body)
+        else
+          raise ArgumentError
+        end
+      end
+
+      def create(klass, endpoint, attributes)
+        request(klass, endpoint, :post, attributes)
+      end
+
+      def update(klass, endpoint, id, attributes)
+        request(klass, endpoint, :put, attributes.merge(id: id))
+      end
+
+      def request(klass, endpoint, method, attributes) # rubocop:disable Metrics/AbcSize
+        model = klass.new(attributes)
+        model.tap do |m|
+          response = connection.public_send(method, endpoint, body: m.as_json)
+          m.set_attributes(response.body) if response.body.is_a?(Hash)
+          m.confirmable_action_id = extract_confirmable_id(response.headers)
+        end
+      rescue Faraday::ClientError => e
+        raise if e.response[:status] != 422
+        model.tap { |m| m.parse_errors(e.response[:body]) }
+      end
+
+      POSSIBLE_CONFIRMABLE_HEADERS = %w[x-fidor-confirmation-path location].freeze
+
+      def extract_confirmable_id(headers)
+        return if (tuple = headers.detect { |key, _| POSSIBLE_CONFIRMABLE_HEADERS.include? key }).nil?
+        tuple.last.split('/').last
+      end
+    end
+  end
+end

data/lib/fidor_api/client.rb

@@ -1,27 +1,23 @@
 module FidorApi
-
   class Client
-    include ActiveModel::Model
+    autoload :Authentication, 'fidor_api/client/authentication'
+    autoload :Configuration,  'fidor_api/client/configuration'
+    autoload :Connection,     'fidor_api/client/connection'
+    autoload :DSL,            'fidor_api/client/dsl'
 
-    attr_accessor :token
+    include Authentication
+    include DSL
 
-    include Account::ClientSupport
-    include Beneficiary::ClientSupport
-    include Beneficiary::ACH::ClientSupport
-    include ConfirmableAction::ClientSupport
-    include Customer::ClientSupport
-    include Message::ClientSupport
-    include Preauth::ClientSupport
-    include SessionToken::ClientSupport
-    include Transaction::ClientSupport
-    include Transfer::ACH::ClientSupport
-    include Transfer::Internal::ClientSupport
-    include Transfer::SEPA::ClientSupport
-    include Transfer::FPS::ClientSupport
-    include Transfer::P2pAccountNumber::ClientSupport
-    include Transfer::P2pPhone::ClientSupport
-    include Transfer::P2pUsername::ClientSupport
-    include User::ClientSupport
-  end
+    attr_accessor :config
 
+    def initialize
+      self.config = Configuration.new
+      yield(config) if block_given?
+      config.validate!
+    end
+
+    def connection(host: config.environment.api_host)
+      Connection.new(client: self, host: host)
+    end
+  end
 end

data/lib/fidor_api/collection/kaminari_support.rb

@@ -0,0 +1,17 @@
+module FidorApi
+  class Collection
+    module KaminariSupport
+      def last_page?
+        current_page == total_pages
+      end
+
+      def next_page
+        current_page + 1
+      end
+
+      def limit_value
+        per_page
+      end
+    end
+  end
+end

data/lib/fidor_api/collection.rb

@@ -1,46 +1,30 @@
 module FidorApi
-
   class Collection
-    include ActiveModel::Model
-    include Enumerable
-
-    attr_accessor :records
-    attr_accessor :total_pages, :current_page, :limit_value, :total_entries
-
-    def self.build(klass, response)
-      new.tap do |object|
-        data       = response["data"]
-        collection = response["collection"]
-
-        object.records = data.map do |record|
-          class_to_instantiate = if block_given?
-            yield(record)
-          else
-            klass
-          end
+    autoload :KaminariSupport, 'fidor_api/collection/kaminari_support'
 
-          class_to_instantiate.new(record)
-        end
-
-        object.total_pages   = collection["total_pages"]
-        object.current_page  = collection["current_page"]
-        object.limit_value   = collection["per_page"]
-        object.total_entries = collection["total_entries"]
-      end
+    include Enumerable
+    include KaminariSupport
+
+    attr_reader \
+      :current_page,
+      :per_page,
+      :total_entries,
+      :total_pages
+
+    def initialize(klass:, raw:)
+      @current_page  = raw.fetch('collection').fetch('current_page')
+      @per_page      = raw.fetch('collection').fetch('per_page')
+      @total_entries = raw.fetch('collection').fetch('total_entries')
+      @total_pages   = raw.fetch('collection').fetch('total_pages')
+      @records       = raw.fetch('data').map { |attributes| klass.new(attributes) }
     end
 
     def each(&block)
       records.each(&block)
     end
 
-    # --- kaminari stuff -- maybe move somewhere else
-    def last_page?
-      current_page == total_pages
-    end
+    private
 
-    def next_page
-      current_page + 1
-    end
+    attr_reader :records
   end
-
 end