fidor_api 0.0.2 → 0.1.0

data/lib/fidor_api/customer.rb

@@ -1,8 +1,9 @@
 module FidorApi
-
-  class Customer < Resource
+  class Customer < Connectivity::Resource
     extend ModelAttribute
 
+    self.endpoint = Connectivity::Endpoint.new('/customers', :collection)
+
     module Gender
       extend self
 
@@ -12,7 +13,7 @@ module FidorApi
 
       class Male    < Base; end
       class Female  < Base; end
-      class Unknonw < Base; end
+      class Unknown < Base; end
 
       MAPPING = {
         Male   => "m",
@@ -20,7 +21,7 @@ module FidorApi
       }
 
       def for_api_value(api_value)
-        MAPPING.key(api_value) || Unknonw
+        MAPPING.key(api_value) || Unknown
       end
 
       def object_to_string(object)
@@ -64,13 +65,13 @@ module FidorApi
     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.all(access_token, options = {})
-      Collection.build(self, request(access_token: access_token, endpoint: "/customers", query_params: options).body)
-    end
-
-    def self.first(access_token)
-      all(access_token, page: 1, per_page: 1).first
+    def self.first
+      all(page: 1, per_page: 1).first
     end
 
     def initialize(*args)
@@ -78,6 +79,20 @@ module FidorApi
       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
@@ -94,29 +109,32 @@ module FidorApi
       attributes.tap { |a| a[:birthday] = a[:birthday].try(:to_date) }
     end
 
-    def save
-      if id.nil?
-        create(htauth: true, access_token: nil)
-      else
-        raise NoUpdatesAllowedError
-      end
-    end
-
     private
 
-    def self.resource
-      "customers"
+    def remote_create
+      endpoint.for(self).post(payload: self.as_json, tokenless: true)
     end
 
     module ClientSupport
       def customers(options = {})
-        Customer.all(token.access_token, options)
+        Customer.all(options)
       end
 
       def first_customer
-        Customer.first(token.access_token)
+        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

@@ -0,0 +1,19 @@
+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/errors.rb

@@ -6,12 +6,23 @@ module FidorApi
   InvalidRecordError     = Class.new(Error)
   NoUpdatesAllowedError  = Class.new(Error)
 
+  class ForbiddenError < Error
+    attr_accessor :code, :key
+
+    def initialize(message, code, key)
+      super(message)
+      self.code = code
+      self.key  = key
+    end
+  end
+
   class ValidationError < Error
-    attr_accessor :fields
+    attr_accessor :fields, :error_keys
 
-    def initialize(message, fields)
+    def initialize(message, fields, error_keys)
       super(message)
-      self.fields = fields
+      self.fields     = fields
+      self.error_keys = error_keys
     end
   end
 

data/lib/fidor_api/message.rb

@@ -1,9 +1,10 @@
 module FidorApi
-
-  class Message < Resource
+  class Message < Connectivity::Resource
     extend ModelAttribute
     extend AmountAttributes
 
+    self.endpoint = Connectivity::Endpoint.new('/messages', :collection)
+
     attribute :id,         :integer
     attribute :subject,    :string
     attribute :type,       :string
@@ -17,17 +18,8 @@ module FidorApi
       attr_accessor :type, :filename, :content
     end
 
-    def self.all(access_token, options = {})
-      Collection.build(self, request(access_token: access_token, endpoint: "/messages", query_params: options).body)
-    end
-
-    def self.find(access_token, id)
-      new(request(access_token: access_token, endpoint: "/messages/#{id}").body)
-    end
-
-    def self.attachment(access_token, id)
-      response = request(access_token: access_token, endpoint: "/messages/#{id}/attachment")
-
+    def attachment
+      response = endpoint.for(self).get(action: 'attachment')
       Attachment.new(
         type:     response.headers["content-type"],
         filename: response.headers["content-disposition"][/filename="([^"]+)"/, 1],
@@ -35,19 +27,26 @@ module FidorApi
       )
     end
 
+    def content
+      endpoint.for(self).get(action: 'content').body
+    end
+
     module ClientSupport
       def messages(options = {})
-        Message.all(token.access_token, options)
+        Message.all(options)
       end
 
       def message(id)
-        Message.find(token.access_token, id)
+        Message.find(id)
       end
 
       def message_attachment(id)
-        Message.attachment(token.access_token, id)
+        Message.new(id: id).attachment
+      end
+
+      def message_content(id)
+        Message.new(id: id).content
       end
     end
   end
-
-end
+end

data/lib/fidor_api/msisdn.rb

@@ -21,7 +21,7 @@ module FidorApi
     private
 
     def connection
-      Faraday.new(url: FidorApi.configuration.oauth_url) do |config|
+      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

data/lib/fidor_api/password.rb

@@ -0,0 +1,30 @@
+module FidorApi
+  class Password < Connectivity::Resource
+    extend ModelAttribute
+
+    self.endpoint = Connectivity::Endpoint.new("/password_resets", :collection, version: "2", tokenless: true)
+
+    def self.request_new(email)
+      params = {email: email, type: "reset_token"}
+      response = endpoint.for(self).put(action: "new_token", payload: params)
+      response.body["success"]
+    end
+
+    def self.update(attributes)
+      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,9 +1,10 @@
 module FidorApi
-
-  class Preauth < Resource
+  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
@@ -14,25 +15,17 @@ module FidorApi
     attribute :currency,             :string
     amount_attribute :amount
 
-    def self.all(access_token, options = {})
-      Collection.build(self, request(access_token: access_token, endpoint: "/preauths", query_params: options).body)
-    end
-
-    def self.find(access_token, id)
-      new(request(access_token: access_token, endpoint: "/preauths/#{id}").body)
-    end
-
     def preauth_type_details
       @_preauth_type_details ||= PreauthDetails.build(@preauth_type, @preauth_type_details)
     end
 
     module ClientSupport
       def preauths(options = {})
-        Preauth.all(token.access_token, options)
+        Preauth.all(options)
       end
 
       def preauth(id)
-        Preauth.find(token.access_token, id)
+        Preauth.find(id)
       end
     end
   end

data/lib/fidor_api/session_token.rb

@@ -0,0 +1,20 @@
+module FidorApi
+  class SessionToken < Connectivity::Resource
+    extend ModelAttribute
+    extend AmountAttributes
+
+    attribute :token, :string
+
+    self.endpoint = Connectivity::Endpoint.new('/session_tokens', :collection)
+
+    def self.create(access_token)
+      new endpoint.for(self).post(payload: {access_token: access_token}).body
+    end
+
+    module ClientSupport
+      def create_session_token
+        SessionToken.create(token.access_token)
+      end
+    end
+  end
+end

data/lib/fidor_api/transaction.rb

@@ -1,9 +1,10 @@
 module FidorApi
-
-  class Transaction < Resource
+  class Transaction < Connectivity::Resource
     extend ModelAttribute
     extend AmountAttributes
 
+    self.endpoint = Connectivity::Endpoint.new('/transactions', :collection)
+
     attribute :id,                       :integer
     attribute :account_id,               :string
     attribute :transaction_type,         :string
@@ -18,25 +19,17 @@ module FidorApi
     attribute :updated_at,               :time
     amount_attribute :amount
 
-    def self.all(access_token, options = {})
-      Collection.build(self, request(access_token: access_token, endpoint: "/transactions", query_params: options).body)
-    end
-
-    def self.find(access_token, id)
-      new(request(access_token: access_token, endpoint: "/transactions/#{id}").body)
-    end
-
     def transaction_type_details
       @_transaction_type_details ||= TransactionDetails.build(@transaction_type, @transaction_type_details)
     end
 
     module ClientSupport
       def transactions(options = {})
-        Transaction.all(token.access_token, options)
+        Transaction.all(options)
       end
 
       def transaction(id)
-        Transaction.find(token.access_token, id)
+        Transaction.find(id)
       end
     end
   end

data/lib/fidor_api/transfer/ach.rb

@@ -0,0 +1,46 @@
+module FidorApi
+  module Transfer
+    class ACH < Base
+      include Generic
+
+      attribute :account_number, :string
+      attribute :routing_code,   :string
+
+      validates :contact_name,   presence: true, unless: :beneficiary_reference_passed?
+      validates :account_number, presence: true, unless: :beneficiary_reference_passed?
+      validates :routing_code,   presence: true, unless: :beneficiary_reference_passed?
+
+      def set_attributes(attrs = {})
+        set_beneficiary_attributes(attrs)
+        self.account_number = attrs.fetch("beneficiary", {}).fetch("routing_info", {})["account_number"]
+        self.routing_code   = attrs.fetch("beneficiary", {}).fetch("routing_info", {})["routing_code"]
+        super(attrs.except("beneficiary"))
+      end
+
+      def as_json_routing_type
+        "ACH"
+      end
+
+      def as_json_routing_info
+        {
+          account_number: account_number,
+          routing_code: routing_code
+        }
+      end
+
+      module ClientSupport
+        def ach_transfers(options = {})
+          Transfer::ACH.all(options)
+        end
+
+        def ach_transfer(id)
+          Transfer::ACH.find(id)
+        end
+
+        def build_ach_transfer(attributes = {})
+          Transfer::ACH.new(attributes)
+        end
+      end
+    end
+  end
+end

data/lib/fidor_api/transfer/bank_internal.rb

@@ -0,0 +1,37 @@
+module FidorApi
+  module Transfer
+    class BankInternal < Base
+      include Generic
+      attribute :account_number, :string
+
+      validates :account_number, presence: true, unless: :beneficiary_reference_passed?
+
+      def set_attributes(attrs = {})
+        self.account_number = attrs.fetch("beneficiary", {}).fetch("routing_info", {})["account_number"]
+        super(attrs)
+      end
+
+      def as_json_routing_type
+        'BANK_INTERNAL'
+      end
+
+      def as_json_routing_info
+        {
+          account_number: account_number
+        }
+      end
+
+      private
+
+      def remote_create
+        response = endpoint.for(self).post(payload: self.as_json)
+
+        if path = response.headers["X-Fidor-Confirmation-Path"]
+          self.confirmable_action = ConfirmableAction.new(id: path.split("/").last)
+        end
+
+        response
+      end
+    end
+  end
+end

data/lib/fidor_api/transfer/base.rb

@@ -0,0 +1,36 @@
+module FidorApi
+  module Transfer
+    class Base < Connectivity::Resource
+      self.endpoint = Connectivity::Endpoint.new('/transfers', :collection)
+
+      attr_accessor :confirmable_action
+
+      def save
+        fail InvalidRecordError unless valid?
+        super
+      end
+
+      def needs_confirmation?
+        self.confirmable_action.present?
+      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
+    end
+  end
+end

data/lib/fidor_api/transfer/fps.rb

@@ -0,0 +1,56 @@
+module FidorApi
+  module Transfer
+    class FPS < Base
+      extend ModelAttribute
+      extend AmountAttributes
+
+      self.endpoint = Connectivity::Endpoint.new('/fps_transfers', :collection)
+
+      attribute :id,               :integer
+      attribute :account_id,       :string
+      attribute :user_id,          :string
+      attribute :transaction_id,   :string
+      attribute :remote_account,   :string
+      attribute :remote_sort_code, :string
+      attribute :remote_name,      :string
+      attribute :external_uid,     :string
+      attribute :subject,          :string
+      attribute :currency,         :string
+      attribute :subject,          :string
+      attribute :state,            :string
+      attribute :created_at,       :time
+      attribute :updated_at,       :time
+      amount_attribute :amount
+
+      def self.required_attributes
+        [ :account_id, :external_uid, :remote_account, :remote_sort_code, :remote_name, :amount, :subject ]
+      end
+
+      def self.writeable_attributes
+        required_attributes
+      end
+
+      validates *required_attributes, presence: true
+
+      def as_json
+        attributes.slice *self.class.writeable_attributes
+      end
+
+      private
+
+      module ClientSupport
+        def fps_transfers(options = {})
+          Transfer::FPS.all(options)
+        end
+
+        def fps_transfer(id)
+          Transfer::FPS.find(id)
+        end
+
+        def build_fps_transfer(attributes = {})
+          Transfer::FPS.new(attributes)
+        end
+      end
+    end
+  end
+end

data/lib/fidor_api/transfer/generic.rb

@@ -0,0 +1,134 @@
+module FidorApi
+  module Transfer
+    module Generic
+      ROUTING_INFO_ERROR_PREFIX = "beneficiary.routing_info.".freeze
+
+      def self.included(base)
+        base.extend ModelAttribute
+        base.extend AmountAttributes
+
+        base.validates *required_attributes, presence: true
+        base.validates :beneficiary_unique_name, presence: true, if: -> { create_beneficiary && !beneficiary_reference_passed? }
+
+        base.attribute :id,                      :string
+        base.attribute :account_id,              :string
+        base.attribute :external_uid,            :string
+        base.attribute :subject,                 :string
+        base.attribute :currency,                :string
+        base.attribute :exchange_rate,           :string
+        base.attribute :subject,                 :string
+        base.attribute :state,                   :string
+        base.amount_attribute :amount
+
+        base.attribute :beneficiary_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 :create_beneficiary,      :boolean
+
+        base.attribute :beneficiary_id,          :string
+
+        base.attribute :created_at,              :time
+        base.attribute :updated_at,              :time
+      end
+
+      def self.required_attributes
+        [ :account_id, :external_uid, :amount, :subject, :currency ]
+      end
+
+      def as_json
+        transfer_json_params.merge(beneficiary_json_params)
+      end
+
+      private
+
+      def beneficiary_reference_passed?
+        beneficiary_id.present?
+      end
+
+      def transfer_json_params
+        {
+          account_id: account_id,
+          external_uid: external_uid,
+          amount: (amount * 100).to_i,
+          currency: currency,
+          subject: subject
+        }
+      end
+
+      def beneficiary_json_params
+        if beneficiary_reference_passed?
+          {
+            beneficiary_id: beneficiary_id
+          }
+        else
+          {
+            beneficiary: {
+              unique_name: beneficiary_unique_name.presence,
+              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
+            },
+            create_beneficiary: create_beneficiary
+          }.compact
+        end
+      end
+
+      def set_beneficiary_attributes(attrs)
+        self.beneficiary_unique_name   = attrs.fetch("beneficiary", {})["unique_name"]
+
+        self.contact_name           = attrs.fetch("beneficiary", {}).fetch("contact", {})["name"]
+        self.contact_address_line_1 = attrs.fetch("beneficiary", {}).fetch("contact", {})["address_line_1"]
+        self.contact_address_line_2 = attrs.fetch("beneficiary", {}).fetch("contact", {})["address_line_2"]
+        self.contact_city           = attrs.fetch("beneficiary", {}).fetch("contact", {})["city"]
+        self.contact_country        = attrs.fetch("beneficiary", {}).fetch("contact", {})["country"]
+
+        self.bank_name              = attrs.fetch("beneficiary", {}).fetch("bank",    {})["name"]
+        self.bank_address_line_1    = attrs.fetch("beneficiary", {}).fetch("bank",    {})["address_line_1"]
+        self.bank_address_line_2    = attrs.fetch("beneficiary", {}).fetch("bank",    {})["address_line_2"]
+        self.bank_city              = attrs.fetch("beneficiary", {}).fetch("bank",    {})["city"]
+        self.bank_country           = attrs.fetch("beneficiary", {}).fetch("bank",    {})["country"]
+      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"] == "beneficiary.unique_name"
+            errors.add(:beneficiary_unique_name, hash["message"])
+          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