fidor_api 0.0.2 → 0.1.0

data/lib/fidor_api/card.rb

@@ -1,8 +1,10 @@
 module FidorApi
-
-  class Card < Resource
+  class Card < Connectivity::Resource
     extend ModelAttribute
     extend AmountAttributes
+    include CardLimitAttribute
+
+    self.endpoint = Connectivity::Endpoint.new('/cards', :collection)
 
     attribute :id,                        :integer
     attribute :account_id,                :string
@@ -16,79 +18,60 @@ module FidorApi
     attribute :sms_notification,          :boolean
     attribute :payed,                     :boolean
     attribute :state,                     :string
+    attribute :valid_until,               :time
     attribute :lock_reason,               :string
     attribute :disabled,                  :boolean
+    attribute :address,                   :json
     attribute :created_at,                :time
     attribute :updated_at,                :time
 
     amount_attribute :balance
-    amount_attribute :atm_limit
-    amount_attribute :transaction_single_limit
-    amount_attribute :transaction_volume_limit
 
     def self.required_attributes
-      [ :account_id, :type, :design, :currency, :pin ]
+      %i(account_id type)
     end
 
-    validates *required_attributes, presence: true
-
-    def self.all(access_token, options = {})
-      Collection.build(self, request(access_token: access_token, endpoint: "/cards", query_params: options).body)
+    def self.writeable_attributes
+      required_attributes + %i(pin address)
     end
 
-    def self.find(access_token, id)
-      new(request(access_token: access_token, endpoint: "/cards/#{id}").body)
+    validates(*required_attributes, presence: true)
+
+    def activate
+      endpoint.for(self).put(action: 'activate')
+      true
     end
 
-    def self.lock(access_token, id)
-      request(method: :put, access_token: access_token, endpoint: "/cards/#{id}/lock")
+    def lock
+      endpoint.for(self).put(action: 'lock')
       true
     end
 
-    def self.unlock(access_token, id)
-      request(method: :put, access_token: access_token, endpoint: "/cards/#{id}/unlock")
+    def unlock
+      endpoint.for(self).put(action: 'unlock')
       true
     end
 
-    def save
-      if id.nil?
-        create
+    def cancel(reason: 'lost')
+      case reason
+      when 'lost'
+        endpoint.for(self).put(action: 'cancel')
+      when 'stolen'
+        endpoint.for(self).put(action: 'block')
       else
-        raise NoUpdatesAllowedError
+        fail ArgumentError, "Unknown reason: #{reason.inspect}"
       end
+      true
     end
 
     def as_json
-      attributes.slice *self.class.required_attributes
+      attributes.slice(*self.class.writeable_attributes)
     end
 
-    private
-
-    def self.resource
-      "cards"
-    end
-
-    module ClientSupport
-      def cards(options = {})
-        Card.all(token.access_token, options)
-      end
-
-      def card(id)
-        Card.find(token.access_token, id)
-      end
-
-      def lock_card(id)
-        Card.lock(token.access_token, id)
-      end
-
-      def unlock_card(id)
-        Card.unlock(token.access_token, id)
-      end
-
-      def build_card(attributes = {})
-        Card.new(attributes.merge(client: self))
-      end
+    # comfort shorthands for easier validations
+    %w(name line_1 line_2 city postal_code country).each do |field|
+      define_method("address_#{field}") { address.try :[], field }
+      define_method("address_#{field}=") { |val| self.address ||= {}; address[field] = val }
     end
   end
-
 end

data/lib/fidor_api/card_limit_attribute.rb

@@ -0,0 +1,52 @@
+module FidorApi
+  module CardLimitAttribute
+    def self.included(base)
+      base.attribute :limits, :json
+      base.validate :validate_limits
+    end
+
+    def method_missing(symbol, *args)
+      if m = symbol.to_s.match(/(.*)_limit$/)
+        limits[m[1]]
+      elsif m = symbol.to_s.match(/(.*)_limit=$/)
+        write_limit(m[1], args[0])
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(symbol, include_all = false)
+      if symbol.to_s =~ /.*_limit=?$/
+        return true
+      else
+        super
+      end
+    end
+
+    private
+
+    def write_limit(key, value)
+      self.limits ||= {}
+      # If the client is using BigDecimal, we will cast it to cents for him
+      if value.instance_of?(BigDecimal)
+        self.limits[key] = (value * 100.00).to_i
+      else
+        self.limits[key] = value
+      end
+    end
+
+    def validate_limits
+      limits.each do |key, value|
+        if value.instance_of?(BigDecimal)
+          limits[key] = (value * 100.00).to_i
+        elsif !(value.class.name.in?(INTEGER_CLASSES) || value.instance_of?(NilClass))
+          errors.add(:"#{key}_limit", :not_an_integer)
+          next
+        end
+        if limits[key] < 0
+          errors.add(:"#{key}_limit", :greater_than_or_equal_to, count: 0)
+        end
+      end if limits
+    end
+  end
+end

data/lib/fidor_api/card_limits.rb

@@ -1,42 +1,14 @@
 module FidorApi
-
-  class CardLimits < Resource
+  class CardLimits < Connectivity::Resource
     extend ModelAttribute
-    extend AmountAttributes
-
-    attribute :id, :integer
-    amount_attribute :atm_limit
-    amount_attribute :transaction_single_limit
-    amount_attribute :transaction_volume_limit
-
-    def self.find(access_token, id)
-      attributes = request(access_token: access_token, endpoint: "/cards/#{id}/limits").body
-      attributes.merge!(id: id)
-      new(attributes)
-    end
+    include CardLimitAttribute
 
-    def self.change(access_token, id, limits = {})
-      attributes = limits.merge(id: id)
+    self.endpoint = Connectivity::Endpoint.new('/cards/:id/limits', :resource)
 
-      new(attributes).tap do |record|
-        record.set_attributes request(
-          method:       :put,
-          access_token: access_token,
-          endpoint:     "/cards/#{id}/limits",
-          body:         record.as_json
-        ).body
-      end
-    end
-
-    module ClientSupport
-      def card_limits(id)
-        CardLimits.find(token.access_token, id)
-      end
+    attribute :id, :integer
 
-      def change_card_limits(id, limits)
-        CardLimits.change(token.access_token, id, limits)
-      end
+    def as_json
+      attributes.slice(:limits)
     end
   end
-
 end

data/lib/fidor_api/client.rb

@@ -6,15 +6,21 @@ module FidorApi
     attr_accessor :token
 
     include Account::ClientSupport
-    include Card::ClientSupport
-    include CardLimits::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
 

data/lib/fidor_api/collection.rb

@@ -5,18 +5,27 @@ module FidorApi
     include Enumerable
 
     attr_accessor :records
-    attr_accessor :total_pages, :current_page, :limit_value
+    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 { |record| klass.new(record) }
+        object.records = data.map do |record|
+          class_to_instantiate = if block_given?
+            yield(record)
+          else
+            klass
+          end
 
-        object.total_pages  = collection["total_pages"]
-        object.current_page = collection["current_page"]
-        object.limit_value  = collection["per_page"]
+          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
     end
 
@@ -34,4 +43,4 @@ module FidorApi
     end
   end
 
-end
+end

data/lib/fidor_api/confirmable_action.rb

@@ -0,0 +1,45 @@
+module FidorApi
+  class ConfirmableAction < Connectivity::Resource
+    extend ModelAttribute
+
+    self.endpoint = Connectivity::Endpoint.new('/confirmable/actions', :collection)
+
+    attribute :id,              :string
+    attribute :type,            :string
+    attribute :message,         :string
+    attribute :steps_left,      :json
+    attribute :steps_completed, :json
+    attribute :resource,        :json
+    attribute :succeeded_at,    :time
+    attribute :failed_at,       :time
+    attribute :errored_at,      :time
+    attribute :created_at,      :time
+    attribute :updated_at,      :time
+
+    attribute :otp,             :string
+    attribute :approval,        :string
+
+    def refresh
+      endpoint.for(self).put(action: "refresh")
+      true
+    end
+
+    module ClientSupport
+      def confirmable_actions(options = {})
+        ConfirmableAction.all
+      end
+
+      def confirmable_action(id)
+        ConfirmableAction.find(id)
+      end
+
+      def update_confirmable_action(id, attributes)
+        ConfirmableAction.new(attributes.merge(id: id)).save
+      end
+
+      def refresh_confirmable_action(id)
+        ConfirmableAction.new(id: id).refresh
+      end
+    end
+  end
+end

data/lib/fidor_api/connectivity/connection.rb

@@ -0,0 +1,113 @@
+module FidorApi
+  module Connectivity
+    module Connection
+      extend self
+
+      Response = Struct.new(:status, :headers, :raw_body) do
+        def body
+          if headers["content-type"] =~ /json/
+            JSON.parse(raw_body)
+          else
+            raw_body
+          end
+        end
+      end
+
+      def get(path, options={})
+        request(:get, path, options)
+      end
+
+      def post(path, options={})
+        request(:post, path, options)
+      end
+
+      def put(path, options={})
+        request(:put, path, options)
+      end
+
+      def delete(path, options={})
+        request(:delete, path, options)
+      end
+
+      def with_token(token)
+        self.access_token = token
+        yield
+      end
+
+      private
+
+      def request(method, path, options={})
+        options.reverse_merge! version: 1, access_token: Connectivity.access_token
+        response = faraday.public_send(method, [FidorApi.configuration.api_path, path].compact.join) do |request|
+          request.params = options[:query_params] if options[:query_params]
+          request.headers = {}
+          if options[:access_token]
+            request.headers["Authorization"] = "Bearer #{options[:access_token]}"
+          else
+            request.headers["Authorization"] = tokenless_http_basic_header
+          end
+          request.headers["Accept"]        = "application/vnd.fidor.de; version=#{options[:version]},text/json"
+          request.headers["Content-Type"]  = "application/json"
+          if options[:body]
+            if options[:body].is_a?(String)
+              request.body = options[:body]
+            elsif options[:body].respond_to?(:to_json)
+              request.body = options[:body].to_json
+            else
+              fail ArgumentError, "unhandled body type #{options[:body].inspect}"
+            end
+          end
+        end
+        if response.status == 303 && URI.parse(response.headers["Location"]).path =~ /^(\/fidor_api)?\/confirmable\//
+          confirmable_action = ConfirmableAction.new(id: URI.parse(response.headers["Location"]).path.split("/").last)
+          raise ApprovalRequired.new(confirmable_action)
+        end
+        Response.new(response.status, response.headers, response.body)
+      rescue Faraday::Error::ClientError => e
+        log :info,  "Error (#{e.class.name}): #{e.to_s}\nStatus: #{e.response[:status]}"
+        log :debug, "Header: #{e.response[:header]}\nBody: #{e.response[:body]}" if e.response[:status] != 500
+        case e.response[:status]
+        when 401
+          raise UnauthorizedTokenError
+        when 403
+          body = JSON.parse(e.response[:body])
+          raise ForbiddenError.new(body["message"], body["code"], body["key"])
+        when 422
+          body = JSON.parse(e.response[:body])
+          raise ValidationError.new(body["message"], body["errors"], body["key"])
+        else
+          raise ClientError.new(e.response[:body])
+        end
+      end
+
+      def log(level, message)
+        return unless FidorApi.configuration.logging
+        FidorApi.configuration.logger.public_send(level, message)
+      end
+
+      def logger_type
+        if defined?(Faraday::DetailedLogger)
+          :detailed_logger
+        else
+          :logger
+        end
+      end
+
+      def tokenless_http_basic_header
+        @tokenless_http_basic_header ||= begin
+          base64 = Base64.strict_encode64("#{FidorApi.configuration.htauth_user}:#{FidorApi.configuration.htauth_password}")
+          "Basic #{base64}"
+        end
+      end
+
+      def faraday
+        @faraday ||= Faraday.new(url: FidorApi.configuration.api_url, ssl: { verify: FidorApi.configuration.verify_ssl }) do |config|
+          config.request  :url_encoded
+          config.response logger_type, FidorApi.configuration.logger if FidorApi.configuration.logging
+          config.response :raise_error
+          config.adapter  Faraday.default_adapter
+        end
+      end
+    end
+  end
+end

data/lib/fidor_api/connectivity/endpoint.rb

@@ -0,0 +1,82 @@
+module FidorApi
+  module Connectivity
+    class Endpoint
+      attr_reader :collection, :resource, :version, :tokenless
+
+      def initialize(path, mode, version: '1', tokenless: false)
+        @path = path
+        @version = version
+        @tokenless = tokenless
+
+        case mode
+        when :collection
+          @collection = path
+          @resource = "#{path}/:id"
+        when :resource
+          @resource = path
+        else
+          fail ArgumentError, "mode #{mode.inspect} must be resource or collection"
+        end
+      end
+
+      class Context
+        def initialize(endpoint, object)
+          @endpoint = endpoint
+          @object = object
+        end
+
+        def get(target: :resource, action: nil, query_params: nil, tokenless: nil)
+          request :get, target, action, query_params: query_params, tokenless: tokenless
+        end
+
+        def post(target: :collection, action: nil, payload: nil, tokenless: nil)
+          request :post, target, action, body: payload, tokenless: tokenless
+        end
+
+        def put(target: :resource, action: nil, payload: nil, tokenless: nil)
+          request :put, target, action, body: payload, tokenless: tokenless
+        end
+
+        def delete(target: :resource, action: nil, tokenless: nil)
+          request :delete, target, action, tokenless: tokenless
+        end
+
+        private
+
+        def request(method, target, action, options = {})
+          options.reverse_merge! version: @endpoint.version
+          options[:access_token] = nil if options[:tokenless] || @endpoint.tokenless
+          Connection.public_send(method, send("#{target}_path", action), options)
+        end
+
+        def resource_path(action = nil)
+          interpolate(@endpoint.resource, action)
+        end
+
+        def collection_path(action = nil)
+          interpolate(@endpoint.collection, action)
+        end
+
+        def interpolate(path, suffix = nil)
+          [path, suffix].compact.join('/').gsub(/:(\w+)/) do |m|
+            fetch_option $1
+          end
+        end
+
+        def fetch_option(name)
+          if @object.kind_of? Hash
+            @object[name]
+          elsif @object.class.name.in?(INTEGER_CLASSES) || @object.kind_of?(String)
+            @object
+          elsif @object.respond_to? name
+            @object.public_send name
+          end
+        end
+      end
+
+      def for(object)
+        Context.new(self, object)
+      end
+    end
+  end
+end

data/lib/fidor_api/connectivity/resource.rb

@@ -0,0 +1,76 @@
+module FidorApi
+  module Connectivity
+    class Resource
+      include ActiveModel::Model
+      extend ModelAttribute
+
+      class_attribute :endpoint
+
+      attr_accessor :error_keys
+
+      class << self
+        def find(id)
+          new endpoint.for(id).get.body.reverse_merge(id: id)
+        end
+
+        def all(options = {})
+          FidorApi::Collection.build self, endpoint.for(self).get(target: :collection, query_params: options).body
+        end
+
+        def model_name
+          ActiveModel::Name.new(self, nil, self.name.sub("FidorApi::", ""))
+        end
+      end
+
+      def initialize(attributes = {})
+        set_attributes attributes
+      end
+
+      def reload
+        set_attributes endpoint.for(self).get.body
+      end
+
+      def persisted?
+        id.present?
+      end
+
+      def save
+        if valid?
+          set_attributes(persisted? ? remote_update.body : remote_create.body)
+          true
+        else
+          false
+        end
+      rescue ValidationError => e
+        self.error_keys = e.error_keys
+        map_errors(e.fields)
+        false
+      end
+
+      def update_attributes(attributes={})
+        set_attributes attributes
+        valid? and remote_update attributes.keys
+      end
+
+      private
+
+      def remote_create
+        endpoint.for(self).post(payload: self.as_json)
+      end
+
+      def remote_update(*attributes)
+        payload = self.as_json.with_indifferent_access
+        payload.slice!(*attributes.flatten) if attributes.present?
+        endpoint.for(self).put(payload: payload)
+      end
+
+      def map_errors(fields)
+        fields.each do |hash|
+          hash.symbolize_keys!
+          field = hash[:field].to_sym
+          errors.add(field, hash[:message], hash) if respond_to?(field) || field == :base
+        end
+      end
+    end
+  end
+end

data/lib/fidor_api/connectivity.rb

@@ -0,0 +1,17 @@
+module FidorApi
+  module Connectivity
+    extend self
+
+    autoload :Connection, 'fidor_api/connectivity/connection'
+    autoload :Resource, 'fidor_api/connectivity/resource'
+    autoload :Endpoint, 'fidor_api/connectivity/endpoint'
+
+    def access_token=(val)
+      Thread.current[:fidor_api_access_token] = val
+    end
+
+    def access_token
+      Thread.current[:fidor_api_access_token]
+    end
+  end
+end

data/lib/fidor_api/constants.rb

@@ -0,0 +1,3 @@
+module FidorApi
+  INTEGER_CLASSES = %w(Integer Fixnum Bignum)
+end