fidor_api 1.0.0 → 2.0.0.alpha1

data/lib/fidor_api/connectivity/connection.rb

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

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

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

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

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

data/lib/fidor_api/customer.rb

@@ -1,140 +0,0 @@
-module FidorApi
-  class Customer < Connectivity::Resource
-    extend ModelAttribute
-
-    self.endpoint = Connectivity::Endpoint.new('/customers', :collection)
-
-    module Gender
-      extend self
-
-      class Base
-        include Singleton
-      end
-
-      class Male    < Base; end
-      class Female  < Base; end
-      class Unknown < Base; end
-
-      MAPPING = {
-        Male   => "m",
-        Female => "f"
-      }
-
-      def for_api_value(api_value)
-        MAPPING.key(api_value) || Unknown
-      end
-
-      def object_to_string(object)
-        MAPPING[object]
-      end
-    end
-
-    attribute :id,                        :integer
-    attribute :email,                     :string
-    attribute :first_name,                :string
-    attribute :last_name,                 :string
-    attribute :gender,                    :string
-    attribute :title,                     :string
-    attribute :nick,                      :string
-    attribute :maiden_name,               :string
-    attribute :adr_street,                :string
-    attribute :adr_street_number,         :string
-    attribute :adr_post_code,             :string
-    attribute :adr_city,                  :string
-    attribute :adr_country,               :string
-    attribute :adr_phone,                 :string
-    attribute :adr_mobile,                :string
-    attribute :adr_fax,                   :string
-    attribute :adr_businessphone,         :string
-    attribute :birthday,                  :time
-    attribute :is_verified,               :boolean
-    attribute :nationality,               :string
-    attribute :marital_status,            :integer
-    attribute :religion,                  :integer
-    attribute :id_card_registration_city, :string
-    attribute :id_card_number,            :string
-    attribute :id_card_valid_until,       :time
-    attribute :created_at,                :time
-    attribute :updated_at,                :time
-    attribute :creditor_identifier,       :string
-    attribute :affiliate_uid,             :string
-    attribute :verification_token,        :string
-    attribute :password,                  :string
-    attribute :tos,                       :boolean
-    attribute :privacy_policy,            :boolean
-    attribute :own_interest,              :boolean
-    attribute :us_citizen,                :boolean
-    attribute :us_tax_payer,              :boolean
-    attribute :preferred_language,        :string
-    attribute :community_user_picture,    :string
-    attribute :country_of_birth,          :string
-    attribute :additional_first_name,     :string
-
-    def self.first
-      all(page: 1, per_page: 1).first
-    end
-
-    def initialize(*args)
-      super
-      self.affiliate_uid = FidorApi.configuration.affiliate_uid
-    end
-
-    def request_update(attributes)
-      self.endpoint = Connectivity::Endpoint.new('/customers', :collection, version: '2')
-      endpoint.for(self).put(action: 'request_update', payload: attributes.as_json)
-      true
-    rescue ValidationError => e
-      map_errors(e.fields)
-      false
-    end
-
-    def confirm_update(attributes)
-      self.endpoint = Connectivity::Endpoint.new('/customers', :collection, version: '2')
-      endpoint.for(self).put(action: 'confirm_update', payload: {token: attributes['token']})
-    end
-
-    def gender
-      Gender.for_api_value(@gender)
-    end
-
-    def gender=(value)
-      @gender = if value.class == Class && value.instance.is_a?(FidorApi::Customer::Gender::Base)
-        Gender.object_to_string(value)
-      else
-        value
-      end
-    end
-
-    def as_json(options = nil)
-      attributes.tap { |a| a[:birthday] = a[:birthday].try(:to_date) }
-    end
-
-    private
-
-    def remote_create
-      endpoint.for(self).post(payload: self.as_json, tokenless: true)
-    end
-
-    module ClientSupport
-      def customers(options = {})
-        Customer.all(options)
-      end
-
-      def first_customer
-        Customer.first
-      end
-
-      def update_customer(id, attributes)
-        Customer.endpoint.for(id).put(payload: attributes)
-      end
-
-      def request_customer_update(id, attributes)
-        Customer.new(id: id).request_update(attributes)
-      end
-
-      def confirm_customer_update(id, attributes)
-        Customer.new(id: id).confirm_update(attributes)
-      end
-    end
-  end
-end

data/lib/fidor_api/customers/confirmations.rb

@@ -1,19 +0,0 @@
-module FidorApi
-  module Customers
-    class Confirmations < Connectivity::Resource
-      extend ModelAttribute
-
-      self.endpoint = Connectivity::Endpoint.new('/customers/confirmation', :collection)
-
-      def self.create(*attributes)
-        new(*attributes).save
-      end
-
-      private
-
-      def persisted?
-        false
-      end
-    end
-  end
-end

data/lib/fidor_api/message.rb

@@ -1,52 +0,0 @@
-module FidorApi
-  class Message < Connectivity::Resource
-    extend ModelAttribute
-    extend AmountAttributes
-
-    self.endpoint = Connectivity::Endpoint.new('/messages', :collection)
-
-    attribute :id,         :integer
-    attribute :subject,    :string
-    attribute :type,       :string
-    attribute :opened_at,  :time
-    attribute :created_at, :time
-    attribute :updated_at, :time
-    attribute :category,   :string
-
-    class Attachment
-      include ActiveModel::Model
-      attr_accessor :type, :filename, :content
-    end
-
-    def attachment
-      response = endpoint.for(self).get(action: 'attachment')
-      Attachment.new(
-        type:     response.headers["content-type"],
-        filename: response.headers["content-disposition"][/filename="([^"]+)"/, 1],
-        content:  response.body,
-      )
-    end
-
-    def content
-      endpoint.for(self).get(action: 'content').body
-    end
-
-    module ClientSupport
-      def messages(options = {})
-        Message.all(options)
-      end
-
-      def message(id)
-        Message.find(id)
-      end
-
-      def message_attachment(id)
-        Message.new(id: id).attachment
-      end
-
-      def message_content(id)
-        Message.new(id: id).content
-      end
-    end
-  end
-end

data/lib/fidor_api/msisdn.rb

@@ -1,45 +0,0 @@
-module FidorApi
-
-  module Msisdn
-    extend self
-
-    def check(msisdn)
-      post "/msisdn/check", {
-        msisdn:        msisdn,
-        os_type:       FidorApi.configuration.os_type,
-        affiliate_uid: FidorApi.configuration.affiliate_uid
-      }
-    end
-
-    def verify(msisdn, code)
-      post "/msisdn/verify", {
-        msisdn: msisdn,
-        code:   code
-      }
-    end
-
-    private
-
-    def connection
-      Faraday.new(url: FidorApi.configuration.oauth_url, ssl: { verify: FidorApi.configuration.verify_ssl }) do |config|
-        config.use      Faraday::Request::BasicAuthentication, FidorApi.configuration.htauth_user, FidorApi.configuration.htauth_password
-        config.request  :url_encoded
-        config.response :logger if FidorApi.configuration.logging
-        config.response :raise_error
-        config.adapter  Faraday.default_adapter
-      end
-    end
-
-    def post(endpoint, body)
-      response = connection.post endpoint do |request|
-        request.headers = {
-          "Accept"       => "application/vnd.fidor.de; version=1,text/json",
-          "Content-Type" => "application/json"
-        }
-        request.body = body.to_json
-      end
-      response.body
-    end
-  end
-
-end

data/lib/fidor_api/password.rb

@@ -1,29 +0,0 @@
-module FidorApi
-  class Password < Connectivity::Resource
-    extend ModelAttribute
-
-    def self.request_new(email)
-      endpoint = Connectivity::Endpoint.new("/password_resets/new_token", :resource, version: "2", tokenless: true)
-      response = endpoint.for(self).put(payload: { email: email, type: "reset_token" })
-      response.body["success"]
-    end
-
-    def self.update(attributes)
-      endpoint = Connectivity::Endpoint.new("/password_resets", :collection, version: "2", tokenless: true)
-      response = endpoint.for(self).post(payload: attributes)
-      response.body["success"]
-    end
-
-    private
-
-    module ClientSupport
-      def request_new_password(email)
-        Password.request_new(email)
-      end
-
-      def update_password(attributes)
-        Password.update(attributes)
-      end
-    end
-  end
-end

data/lib/fidor_api/preauth.rb

@@ -1,33 +0,0 @@
-module FidorApi
-  class Preauth < Connectivity::Resource
-    extend ModelAttribute
-    extend AmountAttributes
-
-    self.endpoint = Connectivity::Endpoint.new('/preauths', :collection)
-
-    attribute :id,                   :integer
-    attribute :account_id,           :string
-    attribute :preauth_type,         :string
-    attribute :preauth_type_details, :json
-    attribute :expires_at,           :time
-    attribute :created_at,           :time
-    attribute :updated_at,           :time
-    attribute :currency,             :string
-    amount_attribute :amount
-
-    def preauth_type_details
-      @_preauth_type_details ||= PreauthDetails.build(@preauth_type, @preauth_type_details)
-    end
-
-    module ClientSupport
-      def preauths(options = {})
-        Preauth.all(options)
-      end
-
-      def preauth(id)
-        Preauth.find(id)
-      end
-    end
-  end
-
-end