fidor_api 1.0.0 → 2.0.0.alpha1

data/lib/fidor_api/auth.rb

@@ -1,45 +0,0 @@
-module FidorApi
-
-  module Auth
-    extend self
-
-    def authorize_url(callback_url: nil)
-      fidor_authorize_url(callback_url: callback_url)
-    end
-
-    def fetch_token(code, callback_url: nil)
-      response = connection.post "/oauth/token", {
-        client_id:    FidorApi.configuration.client_id,
-        redirect_uri: callback_url || FidorApi.configuration.callback_url,
-        code:         code,
-        grant_type:   "authorization_code"
-      }
-      Token.new JSON.parse(response.body)
-    end
-
-    def refresh_token(token)
-      response = connection.post "/oauth/token", {
-        grant_type:    "refresh_token",
-        refresh_token: token.refresh_token
-      }
-      Token.new JSON.parse(response.body)
-    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.client_id, FidorApi.configuration.client_secret
-        config.request  :url_encoded
-        config.response :logger if FidorApi.configuration.logging
-        config.response :raise_error
-        config.adapter  Faraday.default_adapter
-      end
-    end
-
-    def fidor_authorize_url(state: "empty", callback_url:)
-      "#{FidorApi.configuration.oauth_url}/oauth/authorize?client_id=#{FidorApi.configuration.client_id}&redirect_uri=#{CGI::escape(callback_url || FidorApi.configuration.callback_url)}&state=#{state}&response_type=code"
-    end
-  end
-
-end

data/lib/fidor_api/beneficiary/ach.rb

@@ -1,39 +0,0 @@
-module FidorApi
-  module Beneficiary
-    class ACH < Base
-      include Generic
-
-      attribute :account_number, :string
-      attribute :routing_code,   :string
-
-      validates :contact_name,   presence: true
-      validates :account_number, presence: true
-      validates :routing_code,   presence: true
-
-      def set_attributes(attrs = {})
-        self.account_number = attrs.fetch("routing_info", {})["account_number"]
-        self.routing_code   = attrs.fetch("routing_info", {})["routing_code"]
-        super(attrs.except("routing_type", "routing_info"))
-      end
-
-      def as_json_routing_type
-        "ACH"
-      end
-
-      def as_json_routing_info
-        {
-          account_number: account_number,
-          routing_code:   routing_code
-        }
-      end
-
-      private
-
-      module ClientSupport
-        def build_ach_beneficiary(attributes = {})
-          Beneficiary::ACH.new(attributes)
-        end
-      end
-    end
-  end
-end

data/lib/fidor_api/beneficiary/base.rb

@@ -1,118 +0,0 @@
-module FidorApi
-  module Beneficiary
-    class Base < Connectivity::Resource
-      ROUTING_INFO_ERROR_PREFIX = "routing_info.".freeze
-
-      self.endpoint = Connectivity::Endpoint.new('/beneficiaries', :collection)
-
-      attr_accessor :confirmable_action
-
-      class << self
-        def new(hash={})
-          if self == Base
-            class_for_response_hash(hash).new hash
-          else
-            super
-          end
-        end
-
-        def delete(id)
-          endpoint.for(new(id: id)).delete
-          true
-        end
-
-        private
-
-        def class_for_response_hash(hash)
-          {
-            "FOS_P2P_ACCOUNT_NUMBER" => FidorApi::Beneficiary::P2pAccountNumber,
-            "FOS_P2P_PHONE"          => FidorApi::Beneficiary::P2pPhone,
-            "FOS_P2P_USERNAME"       => FidorApi::Beneficiary::P2pUsername,
-            "SWIFT"                  => FidorApi::Beneficiary::Swift,
-            "UTILITY"                => FidorApi::Beneficiary::Utility
-          }.fetch(hash["routing_type"], FidorApi::Beneficiary::Unknown)
-        end
-      end
-
-      def set_attributes(attrs = {})
-        self.contact_name           = attrs.fetch("contact", {})["name"]
-        self.contact_address_line_1 = attrs.fetch("contact", {})["address_line_1"]
-        self.contact_address_line_2 = attrs.fetch("contact", {})["address_line_2"]
-        self.contact_city           = attrs.fetch("contact", {})["city"]
-        self.contact_country        = attrs.fetch("contact", {})["country"]
-
-        self.bank_name              = attrs.fetch("bank",    {})["name"]
-        self.bank_address_line_1    = attrs.fetch("bank",    {})["address_line_1"]
-        self.bank_address_line_2    = attrs.fetch("bank",    {})["address_line_2"]
-        self.bank_city              = attrs.fetch("bank",    {})["city"]
-        self.bank_country           = attrs.fetch("bank",    {})["country"]
-
-        super(attrs.except("contact", "bank", "routing_type", "routing_info"))
-      end
-
-      def save
-        fail InvalidRecordError unless valid?
-        super
-      end
-
-      def as_json
-        {
-          account_id:  account_id,
-          unique_name: unique_name,
-          contact: {
-            name:           contact_name,
-            address_line_1: contact_address_line_1,
-            address_line_2: contact_address_line_2,
-            city:           contact_city,
-            country:        contact_country
-          }.compact,
-          bank: {
-            name:           bank_name,
-            address_line_1: bank_address_line_1,
-            address_line_2: bank_address_line_2,
-            city:           bank_city,
-            country:        bank_country
-          }.compact,
-          routing_type: as_json_routing_type,
-          routing_info: as_json_routing_info
-        }.compact
-      end
-
-      private
-
-      def remote_create
-        response = super
-        if path = response.headers["X-Fidor-Confirmation-Path"]
-          self.confirmable_action = ConfirmableAction.new(id: path.split("/").last)
-        end
-        response
-      end
-
-      def remote_update(*attributes)
-        response = super
-        if path = response.headers["X-Fidor-Confirmation-Path"]
-          self.confirmable_action = ConfirmableAction.new(id: path.split("/").last)
-        end
-        response
-      end
-
-      def map_errors(fields)
-        fields.each do |hash|
-          field = hash["field"].to_sym
-          key   = hash["key"].try :to_sym
-
-          if field == :base || respond_to?(field)
-            if key
-              errors.add(field, key, message: hash["message"])
-            else
-              errors.add(field, hash["message"])
-            end
-          elsif hash["field"].start_with?(ROUTING_INFO_ERROR_PREFIX)
-            invalid_field = hash["field"][ROUTING_INFO_ERROR_PREFIX.size..-1]
-            errors.add(invalid_field, hash["key"].to_sym, message: hash["message"])
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fidor_api/beneficiary/generic.rb

@@ -1,24 +0,0 @@
-module FidorApi
-  module Beneficiary
-    module Generic
-      def self.included(base)
-        base.extend ModelAttribute
-
-        base.attribute :id,                     :string
-        base.attribute :account_id,             :string
-        base.attribute :unique_name,            :string
-        base.attribute :contact_name,           :string
-        base.attribute :contact_address_line_1, :string
-        base.attribute :contact_address_line_2, :string
-        base.attribute :contact_city,           :string
-        base.attribute :contact_country,        :string
-        base.attribute :bank_name,              :string
-        base.attribute :bank_address_line_1,    :string
-        base.attribute :bank_address_line_2,    :string
-        base.attribute :bank_city,              :string
-        base.attribute :bank_country,           :string
-        base.attribute :verified,               :boolean
-      end
-    end
-  end
-end

data/lib/fidor_api/beneficiary/p2p_account_number.rb

@@ -1,14 +0,0 @@
-module FidorApi
-  module Beneficiary
-    class P2pAccountNumber < Base
-      include Generic
-
-      attribute :account_number, :string
-
-      def set_attributes(attrs = {})
-        self.account_number = attrs.fetch("routing_info", {})["account_number"]
-        super(attrs.except("routing_type", "routing_info"))
-      end
-    end
-  end
-end

data/lib/fidor_api/beneficiary/p2p_phone.rb

@@ -1,14 +0,0 @@
-module FidorApi
-  module Beneficiary
-    class P2pPhone < Base
-      include Generic
-
-      attribute :mobile_phone_number, :string
-
-      def set_attributes(attrs = {})
-        self.mobile_phone_number = attrs.fetch("routing_info", {})["mobile_phone_number"]
-        super(attrs.except("routing_type", "routing_info"))
-      end
-    end
-  end
-end

data/lib/fidor_api/beneficiary/p2p_username.rb

@@ -1,14 +0,0 @@
-module FidorApi
-  module Beneficiary
-    class P2pUsername < Base
-      include Generic
-
-      attribute :username, :string
-
-      def set_attributes(attrs = {})
-        self.username = attrs.fetch("routing_info", {})["username"]
-        super(attrs.except("routing_type", "routing_info"))
-      end
-    end
-  end
-end

data/lib/fidor_api/beneficiary/swift.rb

@@ -1,35 +0,0 @@
-module FidorApi
-  module Beneficiary
-    class Swift < Base
-      include Generic
-
-      attribute :account_number,   :string
-      attribute :swift_code,       :string
-      attribute :account_currency, :string
-
-      validates :account_number,   presence: true
-      validates :swift_code,       presence: true
-      validates :contact_name,     presence: true
-      validates :account_currency, presence: true
-
-      def set_attributes(attrs = {})
-        self.account_number   = attrs.fetch("routing_info", {})["account_number"]
-        self.swift_code       = attrs.fetch("routing_info", {})["swift_code"]
-        self.account_currency = attrs.fetch("routing_info", {})["account_currency"]
-        super(attrs.except("routing_type", "routing_info"))
-      end
-
-      def as_json_routing_type
-        "SWIFT"
-      end
-
-      def as_json_routing_info
-        {
-          account_number:   account_number,
-          swift_code:       swift_code,
-          account_currency: account_currency
-        }
-      end
-    end
-  end
-end

data/lib/fidor_api/beneficiary/unknown.rb

@@ -1,16 +0,0 @@
-module FidorApi
-  module Beneficiary
-    class Unknown < Base
-      include Generic
-
-      attribute :routing_type, :string
-      attribute :routing_info, :json
-
-      def set_attributes(attrs = {})
-        self.routing_type = attrs["routing_type"]
-        self.routing_info = attrs["routing_info"]
-        super(attrs.except("routing_type", "routing_info"))
-      end
-    end
-  end
-end

data/lib/fidor_api/beneficiary/utility.rb

@@ -1,35 +0,0 @@
-module FidorApi
-  module Beneficiary
-    class Utility < Base
-      include Generic
-
-      attribute :utility_provider,        :string
-      attribute :utility_service,         :string
-      attribute :utility_service_number,  :string
-
-      validates :utility_provider,        presence: true
-      validates :utility_service,         presence: true
-      validates :utility_service_number,  presence: true
-      validates :unique_name,             presence: true
-
-      def set_attributes(attrs = {})
-        self.utility_provider        = attrs.fetch("routing_info", {})["utility_provider"]
-        self.utility_service         = attrs.fetch("routing_info", {})["utility_service"]
-        self.utility_service_number  = attrs.fetch("routing_info", {})["utility_service_number"]
-        super(attrs.except("routing_type", "routing_info"))
-      end
-
-      def as_json_routing_type
-        "UTILITY"
-      end
-
-      def as_json_routing_info
-        {
-          utility_provider:        utility_provider,
-          utility_service:         utility_service,
-          utility_service_number:  utility_service_number
-        }
-      end
-    end
-  end
-end

data/lib/fidor_api/beneficiary.rb

@@ -1,27 +0,0 @@
-module FidorApi
-  module Beneficiary
-    autoload :Base,             'fidor_api/beneficiary/base'
-    autoload :Generic,          'fidor_api/beneficiary/generic'
-    autoload :ACH,              'fidor_api/beneficiary/ach'
-    autoload :P2pAccountNumber, 'fidor_api/beneficiary/p2p_account_number'
-    autoload :P2pPhone,         'fidor_api/beneficiary/p2p_phone'
-    autoload :P2pUsername,      'fidor_api/beneficiary/p2p_username'
-    autoload :Swift,            'fidor_api/beneficiary/swift'
-    autoload :Unknown,          'fidor_api/beneficiary/unknown'
-    autoload :Utility,          'fidor_api/beneficiary/utility'
-
-    module ClientSupport
-      def beneficiaries(options = {})
-        Beneficiary::Base.all(options)
-      end
-
-      def beneficiary(id)
-        Beneficiary::Base.find(id)
-      end
-
-      def delete_beneficiary(id)
-        Beneficiary::Base.delete(id)
-      end
-    end
-  end
-end

data/lib/fidor_api/card.rb

@@ -1,77 +0,0 @@
-module FidorApi
-  class Card < Connectivity::Resource
-    extend ModelAttribute
-    extend AmountAttributes
-    include CardLimitAttribute
-
-    self.endpoint = Connectivity::Endpoint.new('/cards', :collection)
-
-    attribute :id,                        :integer
-    attribute :account_id,                :string
-    attribute :inscription,               :string
-    attribute :pin,                       :string
-    attribute :type,                      :string
-    attribute :design,                    :string
-    attribute :currency,                  :string
-    attribute :physical,                  :boolean
-    attribute :email_notification,        :boolean
-    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
-
-    def self.required_attributes
-      %i(account_id type)
-    end
-
-    def self.writeable_attributes
-      required_attributes + %i(pin address)
-    end
-
-    validates(*required_attributes, presence: true)
-
-    def activate
-      endpoint.for(self).put(action: 'activate')
-      true
-    end
-
-    def lock
-      endpoint.for(self).put(action: 'lock')
-      true
-    end
-
-    def unlock
-      endpoint.for(self).put(action: 'unlock')
-      true
-    end
-
-    def cancel(reason: 'lost')
-      case reason
-      when 'lost'
-        endpoint.for(self).put(action: 'cancel')
-      when 'stolen'
-        endpoint.for(self).put(action: 'block')
-      else
-        fail ArgumentError, "Unknown reason: #{reason.inspect}"
-      end
-      true
-    end
-
-    def as_json
-      attributes.slice(*self.class.writeable_attributes)
-    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

@@ -1,52 +0,0 @@
-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,14 +0,0 @@
-module FidorApi
-  class CardLimits < Connectivity::Resource
-    extend ModelAttribute
-    include CardLimitAttribute
-
-    self.endpoint = Connectivity::Endpoint.new('/cards/:id/limits', :resource)
-
-    attribute :id, :integer
-
-    def as_json
-      attributes.slice(:limits)
-    end
-  end
-end

data/lib/fidor_api/confirmable_action.rb

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