besepa 0.2

data/lib/besepa/business_account.rb

@@ -0,0 +1,37 @@
+module Besepa
+
+  class BusinessAccount < Besepa::Resource
+    
+    include Besepa::ApiCalls::List
+    include Besepa::ApiCalls::Create
+    include Besepa::ApiCalls::Update
+#    include Besepa::ApiCalls::Destroy
+            
+    FIELDS = [:id, :iban, :bic, :bank_name, :status, :default, :core_enabled, :core_suffix, :b2b_enabled, :b2b_suffix]  
+    
+    FIELDS.each do |f|
+      attr_accessor f
+    end   
+        
+    def self.klass_name
+      "bank_account"
+    end
+
+    def set_as_default
+      response = put "/#{api_path}/set_as_default"
+      process_attributes(response['response'])
+      self
+    end
+    
+    protected 
+    
+      def self.api_path(filters={})
+        "/account/bank_accounts"
+      end
+
+      def api_path(filters={})
+        "/account/bank_accounts/#{CGI.escape(id)}"
+      end
+
+  end
+end

data/lib/besepa/customer.rb

@@ -0,0 +1,134 @@
+module Besepa
+
+  class Customer < Besepa::Resource
+    
+    include Besepa::ApiCalls::List
+    include Besepa::ApiCalls::Create
+    include Besepa::ApiCalls::Update
+    include Besepa::ApiCalls::Destroy
+        
+    FIELDS = [:id, :name, :taxid, :reference,
+              :contact_name, :contact_email, :contact_phone, :contact_language,
+              :address_street, :address_city, :address_postalcode, :address_state, :address_country,
+              :status]
+    
+    FIELDS.each do |f|
+      attr_accessor f
+    end
+    
+    # Customer's bank accounts
+    #
+    # @return collection of Besepa::BankAccount
+    def bank_accounts
+      BankAccount.all( {:customer_id => id} )
+    end
+    
+    # Debits sent to this customer
+    #
+    # @return collection of Besepa::Debits
+    def debits
+      Debit.all( {:customer_id => id} )
+    end
+    
+    # Subscriptions from this customer
+    #
+    # @return collection of Besepa::Subscription
+    def subscriptions
+      Subscription.all( {:customer_id => id} )
+    end
+    
+    # List of groups this customers blongs to
+    #
+    # @return collection of Besepa::Group
+    def groups
+      Group.all( {:customer_id => id} )
+    end
+    
+    # Adds this customer to the given group
+    #
+    # @param group_id The ID of the group to which this user should be added
+    #
+    # @return true if user is now a member of the group
+    def add_to_group(group_id)
+      response = post "/#{self.class.api_path}/#{id}/memberships/#{group_id}"
+      response['response'].select{|c| c['id'] == group_id}.any?
+    end
+    
+    # Removed this customer from the given group
+    #
+    # @param group_id The ID of the group from which this user should be removed
+    #
+    # @return true if user is no longer a member of the group
+    def remove_from_group(group_id)
+      response = delete "/#{self.class.api_path}/#{id}/memberships/#{group_id}"
+      response['response'].select{|c| c['id'] == group_id}.empty?
+    end
+    
+    # Creates a new subscription for this customer
+    #
+    # @param starts_at The date this subscription should start (Format: YYYY-MM-DD)
+    # @param product_code The ID of the product the customer is subscribing to
+    # @param bank_account_code The ID of the bank account where debits should be sent to
+    # @param setup_fee Initial set-up fee. Optional, default: 0
+    # @param metadata Optional Hash with metadata related to this subscription, if any. 
+    #
+    # @return new created Besepa::Subscription
+    def add_subscription(starts_at, product_code, bank_account_code, setup_fee=0, metadata=nil)
+      params = {:starts_at => starts_at, :product_id => product_code, :debtor_bank_account_id => bank_account_code}
+      params[:setup_fee] = setup_fee if setup_fee
+      params[:metadata] = metadata if metadata
+      Subscription.create( params, {:customer_id => id} )
+    end
+
+    # Adds a bank account to this customer.
+    # IBAN and BIC are the only mandatory fields. If you already have the mandate signed, you can pass mandate 
+    # detail's and account will be activated by default. Otherwise BankAccount will be marked as inactive (not usable 
+    # for creating debits or subscriptions) until mandate is signed. BankAccount includes mandate's info, including
+    # signature URL.
+    #
+    # @param iban
+    # @param bic
+    # @param bank_name
+    # @param scheme CORE|COR1|B2B. Default: CORE
+    # @param mandate_signature_date Date in which this mandate was signed if already signed (Format: YYYY-MM-DD) 
+    # @param mandate_ref Mandate's reference. If none, Besepa will create one.
+    # @param used Says if this mandate has already been used or not.
+    # @param signature_type Signature to be used: checkbox|sms|biometric
+    # @param phone_number Phone number where the signature SMS will be sent in case signature_type==sms is used.
+    #
+    # @return new created Besepa::BankAccount
+    def add_bank_account(iban, bic, bank_name=nil, scheme='CORE', mandate_signature_date=nil, mandate_ref=nil, used=false, signature_type='checkbox', phone_number=nil)
+      params = {:iban => iban, :bic => bic }
+      params[:mandate] = {scheme: scheme, used: used}
+      if mandate_signature_date
+        params[:mandate][:signed_at] = mandate_signature_date if mandate_signature_date
+        params[:mandate][:reference] = mandate_ref if mandate_ref
+      else
+        params[:mandate][:signature_type] = signature_type
+        params[:mandate][:phone_number] = phone_number if phone_number        
+      end
+      params[:bank_name] = bank_name if bank_name
+      BankAccount.create( params, {:customer_id => id} )
+    end
+    
+    # Generates a direct debit that will be charged to this customer.
+    # 
+    # @param debtor_bank_account_id Customer's BankAccount code this Debit shouyd be charged to.
+    # @param reference Debit's unique reference
+    # @param description Debit's description. Customer will see this in his Bank's statements
+    # @param amount Amount to be charged. Integer, last two digits represent decimals: 10.25 should be 1025
+    # @param collect_at Date in which the charge should be made (Format: YYYY-MM-DD).
+    # @param creditor_account_id Business' BankAccount that should receive the money. If none passed, account marked as default in Besepa's dashboard will be used.
+    # @param metadata Optional Hash with metadata related to this debit, if any. 
+    #
+    # @return new created Besepa::Debit
+    def add_debit(debtor_bank_account_id, reference, description, amount, collect_at, creditor_account_id=nil, metadata=nil)
+      params = {:reference => reference, :description => description, :debtor_bank_account_id => debtor_bank_account_id,
+                :amount => amount, :collect_at => collect_at}
+      params[:creditor_account_id] = creditor_account_id if creditor_account_id
+      params[:metadata] = metadata if metadata
+      Debit.create( params, {:customer_id => id} )
+    end
+    
+  end
+end

data/lib/besepa/debit.rb

@@ -0,0 +1,64 @@
+module Besepa
+
+  class Debit < Besepa::Resource
+    
+    include Besepa::ApiCalls::List
+    include Besepa::ApiCalls::Create
+    include Besepa::ApiCalls::Update
+    include Besepa::ApiCalls::Destroy
+        
+    FIELDS = [:id, :reference, :amount, :currency, :status, 
+              :collect_at, :sent_at, :description, :metadata, 
+              :error_code, :platform_error_code]
+    
+    FIELDS.each do |f|
+      attr_accessor f
+    end
+
+    attr_accessor :debtor_bank_account, :creditor_bank_account, :customer, :remittance, :subscription
+
+    def to_hash
+      values = {}
+      self.class::FIELDS.each do |key|
+        values[key] = self.send("#{key.to_s}")
+      end
+      values[:debtor_bank_account] = debtor_bank_account.to_hash if debtor_bank_account
+      values[:creditor_bank_account] = creditor_bank_account.to_hash if creditor_bank_account
+      values[:customer] = customer.to_hash if customer
+      values[:remittance] = remittance.to_hash if remittance
+      values[:subscription] = subscription.to_hash if subscription
+      values
+    end
+
+    protected 
+    
+      def self.api_path(filters={})
+        if filters[:customer_id]
+          "#{Customer.api_path}/#{CGI.escape(filters[:customer_id])}/debits"
+        else
+          "#{Group.api_path}/#{CGI.escape(filters[:group_id])}/debits"
+        end
+      end
+
+      def api_path(filters={})
+        if filters[:customer_id]
+        "#{Customer.api_path}/#{CGI.escape(filters[:customer_id])}/debits/#{CGI.escape(id)}"
+        else
+          "#{Group.api_path}/#{CGI.escape(filters[:group_id])}/debits/#{CGI.escape(id)}"
+        end
+      end
+
+      def process_attributes(attrs)
+        self.class::FIELDS.each do |key|
+          self.send("#{key.to_s}=", attrs[key.to_s] || attrs[key.to_sym])
+        end
+        self.debtor_bank_account = Besepa::BankAccount.new(attrs['debtor_bank_account']) if attrs['debtor_bank_account']
+        self.creditor_bank_account = Besepa::BusinessAccount.new(attrs['creditor_bank_account']) if attrs['creditor_bank_account']
+        self.customer = Besepa::Customer.new(attrs['customer']) if attrs['customer']
+        self.remittance = Besepa::Remittance.new(attrs['remittance']) if attrs['remittance']
+        self.subscription = Besepa::Subscription.new(attrs['subscription']) if attrs['subscription']
+        process_activities(attrs)
+        self
+      end
+  end
+end

data/lib/besepa/errors/besepa_error.rb

@@ -0,0 +1,28 @@
+module Besepa
+
+  module Errors
+    
+    class BesepaError < StandardError
+      
+      attr_reader :error
+      attr_reader :description
+      attr_reader :http_status
+      attr_reader :messages
+
+      def initialize(error=nil, description=nil, http_status=nil, messages=nil)
+        @messages = messages
+        @http_status = http_status
+        @description = description
+        @error = error
+      end
+
+      def to_s
+        status_string = @http_status.nil? ? "" : "(Status #{@http_status}) "
+        "#{status_string}#{@error} (#{@description})"
+      end
+      
+    end
+  
+  end
+
+end

data/lib/besepa/errors/invalid_resource_error.rb

@@ -0,0 +1,11 @@
+module Besepa
+
+  module Errors
+    
+    class InvalidResourceError < BesepaError
+      
+    end
+  
+  end
+
+end

data/lib/besepa/errors/resource_not_found_error.rb

@@ -0,0 +1,11 @@
+module Besepa
+
+  module Errors
+    
+    class ResourceNotFoundError < BesepaError
+      
+    end
+  
+  end
+
+end

data/lib/besepa/group.rb

@@ -0,0 +1,27 @@
+module Besepa
+
+  class Group < Besepa::Resource
+        
+    include Besepa::ApiCalls::List
+    include Besepa::ApiCalls::Create
+    include Besepa::ApiCalls::Update
+    include Besepa::ApiCalls::Destroy
+        
+    FIELDS = [:id, :name, :reference]
+    
+    FIELDS.each do |f|
+      attr_accessor f
+    end    
+
+    protected
+    
+      def self.api_path(filters={})
+        if filters[:customer_id]
+          "#{Customer.api_path}/#{CGI.escape(filters[:customer_id])}/groups"
+        else
+          "/groups"
+        end
+      end
+      
+  end
+end

data/lib/besepa/mandate.rb

@@ -0,0 +1,18 @@
+module Besepa
+
+  class Mandate < Besepa::Resource
+    
+    include Besepa::ApiCalls::List
+        
+    FIELDS = [:id, :signed_at, :status, :description, :signature_type, :mandate_type, :reference, :url, :used, :phone_number, :scheme, :signature_url]
+    
+    FIELDS.each do |f|
+      attr_accessor f
+    end    
+    
+    def api_path
+      "/customers/#{self.customer_id}/#{self.class.api_path}"
+    end
+
+  end
+end

data/lib/besepa/product.rb

@@ -0,0 +1,19 @@
+module Besepa
+
+  class Product < Besepa::Resource
+        
+    include Besepa::ApiCalls::List
+    include Besepa::ApiCalls::Create
+    include Besepa::ApiCalls::Update
+    include Besepa::ApiCalls::Destroy
+        
+    FIELDS = [:id, :name, :amount, :currency, :reference,
+              :recurrent, :max_charges, :periodicity,
+              :status]
+    
+    FIELDS.each do |f|
+      attr_accessor f
+    end    
+
+  end
+end

data/lib/besepa/remittance.rb

@@ -0,0 +1,32 @@
+module Besepa
+
+  class Remittance < Besepa::Resource
+    
+    include Besepa::ApiCalls::List
+        
+    FIELDS = [:id, :collect_at, :send_at, :sent_at, :status, :scheme]
+    
+    attr_accessor :bank_account
+    
+    FIELDS.each do |f|
+      attr_accessor f
+    end    
+      
+    def self.api_path(filters={})
+      "/remittances"
+    end
+    
+    protected
+    
+      def process_attributes(attrs)
+        self.class::FIELDS.each do |key|
+          self.send("#{key.to_s}=", attrs[key.to_s] || attrs[key.to_sym])
+        end
+        self.bank_account = Besepa::BusinessAccount.new(attrs['bank_account']) if attrs['bank_account']
+        process_activities(attrs)
+        self
+      end
+    
+
+  end
+end

data/lib/besepa/resource.rb

@@ -0,0 +1,96 @@
+require 'besepa/utils/request'
+require 'besepa/utils/connection'
+require 'besepa/utils/config'
+
+module Besepa
+        
+  class Resource
+
+    class <<self
+      
+     include Besepa::Utils::Connection
+     include Besepa::Utils::Request
+      
+      def api_path(filters={})
+        "#{klass_name}s"
+      end
+      
+      def klass_name
+        name.split('::')[-1].downcase
+      end
+
+      def handle_errors(http_status, response)
+        error = response['error']
+        desc = response['error_description']
+        msgs = response['messages'] 
+        if error == 'invalid_resource'
+          raise Besepa::Errors::InvalidResourceError.new(error, desc, http_status, msgs)
+        elsif error == 'not_found'
+          raise Besepa::Errors::ResourceNotFoundError.new(error, desc, http_status, msgs)
+        else
+          raise Besepa::Errors::BesepaError.new(error, desc, http_status, msgs)
+        end
+      end
+      
+    end
+
+    include Besepa::Utils::Connection
+    include Besepa::Utils::Request
+
+    attr_accessor :activities
+    
+    def initialize(attrs={})
+      process_attributes(attrs)
+    end
+    
+    def to_hash
+      values = {}
+      self.class::FIELDS.each do |key|
+        values[key] = self.send("#{key.to_s}")
+      end
+      values
+    end
+    
+    def serializable_hash
+      to_hash
+    end
+    
+    def as_json
+      to_hash.as_json
+    end
+    
+    def klass_name
+      self.class.name.split('::')[-1].downcase
+    end
+    
+    protected 
+    
+      def handle_errors(http_status, response)
+        Module.const_get(self.class.name).handle_errors(http_status, response)
+      end
+    
+      def process_attributes(attrs)          
+        self.class::FIELDS.each do |key|
+          self.send("#{key.to_s}=", attrs[key.to_s] || attrs[key.to_sym])
+        end
+        process_activities(attrs)
+      end
+      
+      def process_activities(attrs)
+        if attrs['activities']
+          self.activities = Array.new
+          attrs['activities'].each do |a|
+            self.activities << Besepa::Activity.new(a) 
+          end
+        end
+      end
+      
+      # def api_path(filters={})
+      #   self.class.api_path
+      # end
+
+
+  end
+    
+  
+end