charging-client 0.0.2

data/lib/charging/helpers.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Charging
+  module Helpers
+    module_function
+
+    def load_variables(object, attributes, hash)
+      attributes.each do |attribute|
+        value = hash.fetch(attribute, hash.fetch(attribute.to_s, nil))
+        object.instance_variable_set "@#{attribute}", value
+      end
+    end
+
+    def required_arguments!(arguments)
+      errors = []
+
+      arguments.each do |key, value|
+        errors << "#{key} required" if value.nil?
+      end
+
+      raise ArgumentError, errors.join(', ') if errors.any?
+    end
+
+    def hashify(object, attributes)
+      attributes.inject({}) do |result, attribute|
+        result[attribute] = object.send(attribute)
+        result
+      end
+    end
+    
+    def extract_uuid(uri)
+      uri.split("/").last
+    rescue
+      ""
+    end
+  end
+end

data/lib/charging/http.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+require 'base64'
+
+module Charging
+  module Http # :nodoc:
+    class LastResponseError < RuntimeError
+      attr_reader :last_response
+
+      def initialize(last_response)
+        super
+        @last_response = last_response
+      end
+
+      def message
+        last_response.to_s
+      end
+    end
+
+    module_function
+
+    def get(path, token, params = {})
+      request_to_api(:get, path, params, token)
+    end
+
+    def delete(path, token, etag)
+      request_to_api(:delete, path, {etag: etag}, token)
+    end
+
+    def post(path, token, body = {}, params = {})
+      request_to_api(:post, path, params, token, body)
+    end
+
+    def put(path, token, etag, body = {})
+      request_to_api(:put, path, {etag: etag}, token, body)
+    end
+
+    def patch(path, token, etag, body = {})
+      request_to_api(:patch, path, {etag: etag}, token, body)
+    end
+
+    def basic_credential_for(user, password = nil)
+      credential_for = user.to_s
+      credential_for << ":#{password}" unless password.nil?
+
+      credential = ::Base64.strict_encode64(credential_for)
+      "Basic #{credential}"
+    end
+
+    def should_follow_redirect(follow = true)
+      proc { |response, request, result, &block|
+        if follow && [301, 302, 307].include?(response.code)
+          response.follow_redirection(request, result, &block)
+        else
+          response.return!(request, result, &block)
+        end
+      }
+    end
+    
+    def request_to_api(method, path, params, token, body = nil)
+      path = charging_path(path) unless path.start_with?('http')
+      etag = params.delete(:etag)
+      
+      args = [method, path]
+      args << encoded_body(body) if body
+
+      RestClient.send(*args,
+        {params: params}.merge(common_params(token, etag)),
+        &should_follow_redirect
+      )
+    rescue ::RestClient::Exception => exception
+      raise LastResponseError.new(exception.response)
+    end
+
+    def charging_path(path)
+      "#{Charging.configuration.url}#{path}"
+    end
+
+    def common_params(token, etag)
+      token = Charging.configuration.application_token if token === :use_application_token
+      request_headers = {
+        authorization: basic_credential_for('', token),
+        content_type: :json,
+        accept: :json,
+        user_agent: Charging.configuration.user_agent
+      }
+
+      request_headers['If-Match'] = etag if etag
+
+      request_headers
+    end
+
+    def encoded_body(body)
+      body.is_a?(Hash) ? MultiJson.encode(body) : body
+    end
+  end
+end

data/lib/charging/invoice.rb

@@ -0,0 +1,191 @@
+# encoding: utf-8
+
+module Charging
+  class Invoice < Base
+    ATTRIBUTES = [
+      :kind, :amount, :document_number, :drawee, :due_date, :portfolio_code,
+      :charging_features, :supplier_name, :discount, :interest, :rebate,
+      :ticket, :protest_code, :protest_days, :instructions, :demonstrative,
+      :our_number
+    ]
+
+    READ_ONLY_ATTRIBUTES = [ :document_date, :paid ]
+
+    attr_accessor(*ATTRIBUTES)
+    attr_reader(*READ_ONLY_ATTRIBUTES, :domain, :charge_account)
+
+    def initialize(attributes, domain, charge_account, response = nil)
+      super(attributes, response)
+      @domain = domain
+      @charge_account = charge_account
+    end
+
+    # Creates current invoice at API.
+    #
+    # API method: <tt>POST /charge-accounts/:uuid/invoices/</tt>
+    #
+    # API documentation: https://charging.financeconnect.com.br/static/docs/charges.html#post-charge-accounts-uuid-invoices
+    def create!
+      super do
+        raise 'can not create without a domain' if invalid_domain?
+        raise 'can not create wihtout a charge account' if invalid_charge_account?
+        
+        Invoice.post_charge_accounts_invoices(domain, charge_account, attributes)
+      end
+      
+      reload_attributes!(Helpers.extract_uuid(last_response.headers[:location]) || uuid)
+    end
+    
+    # Deletes the invoice at API
+    # 
+    # API method: <tt>DELETE /invoices/:uuid/</tt>
+    #
+    # API documentation: https://charging.financeconnect.com.br/static/docs/charges.html#delete-invoices-uuid
+    def destroy!
+      super do
+        Http.delete("/invoices/#{uuid}/", domain.token, etag)
+      end
+    end
+    
+    # Pays current invoice at API. You can pass <tt>paid_amount</tt>, 
+    # <tt>payment_date</tt> and <tt>note</tt> about payment. 
+    # Default values:
+    # - <tt>amount</tt>: amount
+    # - <tt>date</tt>:  Time.now.strftime('%Y-%m-%d')
+    #
+    # API method: <tt>POST /invoices/:uuid/pay/</tt>
+    #
+    # API documentation: https://charging.financeconnect.com.br/static/docs/charges.html#post-invoices-uuid-pay
+    def pay!(payment_data = {})
+      reset_errors!
+      
+      attributes = {
+        amount: self.amount,
+        date: Time.now.strftime('%Y-%m-%d')
+      }.merge(payment_data)
+
+      @last_response = Http.post("/invoices/#{uuid}/pay/", domain.token, MultiJson.encode(attributes), etag: self.etag)
+      
+      raise_last_response_unless 201
+      
+      reload_attributes!(uuid)
+    ensure
+      if $ERROR_INFO
+        @last_response = $ERROR_INFO.last_response if $ERROR_INFO.kind_of?(Http::LastResponseError)
+        @errors = [$ERROR_INFO.message]
+      end
+    end
+    
+    # List all payments for an invoice
+    #
+    # API method: <tt>GET /invoices/:uuid/payments/</tt>
+    #
+    # API documentation: https://charging.financeconnect.com.br/static/docs/charges.html#get-invoices-uuid-payments
+    def payments
+      reset_errors!
+      
+      response = Http.get("/invoices/#{uuid}/payments/", domain.token)
+      
+      return [] if response.code != 200
+      
+      MultiJson.decode(response.body)
+    end
+    
+    # Returns a String with the temporary URL for print current invoice.
+    # 
+    # API method: <tt>GET /invoices/:uuid/billet/</tt>
+    # 
+    # API documentation: https://charging.financeconnect.com.br/static/docs/charges.html#get-invoices-uuid-billet
+    def billet_url
+      return if unpersisted?
+      
+      response = Http.get("/invoices/#{uuid}/billet/", domain.token)
+      
+      return if response.code != 200
+      
+      MultiJson.decode(response.body)["billet"]
+    rescue
+      nil
+    end
+
+    # Finds an invoice by uuid. It requites an <tt>domain</tt> and a
+    # <tt>uuid</tt>.
+    #
+    # Returns an Invoice instance or raises a Http::LastResponseError if something
+    # went wrong, like unauthorized request, not found.
+    #
+    # API method: <tt>GET /invoices/:uuid/</tt>
+    #
+    # API documentation: https://charging.financeconnect.com.br/static/docs/charges.html#get-invoices-uuid
+    def self.find_by_uuid(domain, uuid)
+      Helpers.required_arguments!(domain: domain, uuid: uuid)
+      
+      response = Invoice.get_invoice(domain, uuid)
+      
+      raise_last_response_unless 200, response
+      
+      load_persisted_invoice(MultiJson.decode(response.body), response, domain)
+    end
+    
+    # Returns a list of kind of invoices available for current domain. You
+    # SHOULD pass a <tt>domain</tt> instance. You MAY pass a <tt>page</tt>
+    # and <tt>limit</tt> for pagination.
+    # 
+    # API method: <tt>GET /invoices/kinds?page=:page&limit=:limit
+    # 
+    # API documentation:
+    # https://charging.financeconnect.com.br/static/docs/charges.html#get-invoices-kinds-limit-limit-page-page
+    def self.kinds(domain, page = DEFAULT_PAGE, limit = DEFAULT_LIMIT)
+      Helpers.required_arguments!(domain: domain)
+
+      response = Http.get("/invoices/kinds/?page=#{Integer(page)}&limit=#{Integer(limit)}", domain.token)
+      
+      raise_last_response_unless 200, response
+      
+      MultiJson.decode(response)
+    end
+    
+    def self.load_persisted_invoice(attributes, response, domain, charge_account = nil)
+      charge_account_uri = attributes.delete("charge_account").to_s
+      
+      if charge_account.nil? && charge_account_uri.start_with?('http')
+        begin
+          charge_account = ChargeAccount.find_by_uri(domain, charge_account_uri)
+        rescue Http::LastResponseError
+        end
+      end
+      
+      validate_attributes!(attributes)
+      
+      Invoice.new(attributes, domain, charge_account, response)
+    end
+
+    private
+    
+    def reload_attributes!(uuid)
+      new_invoice = self.class.find_by_uuid(domain, uuid)
+
+      (COMMON_ATTRIBUTES + READ_ONLY_ATTRIBUTES).each do |attribute|
+        instance_variable_set "@#{attribute}", new_invoice.send(attribute)
+      end
+
+      self
+    end
+    
+    def self.get_invoice(domain, uuid)
+      Http.get("/invoices/#{uuid}/", domain.token)
+    end
+    
+    def self.post_charge_accounts_invoices(domain, charge_account, attributes)
+      Http.post("/charge-accounts/#{charge_account.uuid}/invoices/", domain.token, MultiJson.encode(attributes))
+    end
+
+    def invalid_domain?
+      domain.nil?
+    end
+
+    def invalid_charge_account?
+      charge_account.nil?
+    end
+  end
+end

data/lib/charging/service_account.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module Charging
+  # Represents a Charging service account.
+  class ServiceAccount
+    ATTRIBUTES = [:plan, :name, :uri, :uuid]
+
+    attr_accessor(*ATTRIBUTES)
+
+    # Responds the last http response from the API.
+    attr_reader :last_response
+
+    # Responds the current application token
+    attr_reader :application_token
+    
+    def self.current
+      @current ||= find_by_token(Charging.configuration.application_token)
+    end
+
+    # Initializes a service account instance, to represent a charging account
+    def initialize(attributes, response, token) # :nodoc:
+      Helpers.load_variables(self, ATTRIBUTES, attributes)
+
+      @last_response = response
+      @application_token = token
+    end
+
+    # Finds a service account by it's access token. Returns the service account
+    # instance with all fields set if successful. If something went wrong, it
+    # raises Charging::Http::LastResponseError.
+    #
+    # API documentation: http://charging.financeconnect.com.br/static/docs/accounts_and_domains.html#get-account-entry-point
+    def self.find_by_token(token)
+      response = Http.get('/account/', token)
+
+      raise Http::LastResponseError.new(response) if response.code != 200
+
+      self.load_service_account_for response, token
+    rescue ::RestClient::Exception => exception
+      raise Http::LastResponseError.new(exception.response)
+    end
+
+    private
+
+    def self.load_service_account_for(response, token)
+      data = MultiJson.decode(response.body)
+      self.new(data, response, token)
+    end
+  end
+end

data/lib/charging/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module Charging
+  VERSION = "0.0.2"
+end

data/spec/charging/charge_account_collection_spec.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Charging::ChargeAccount::Collection do
+  let(:domain_mock) { double(:domain, token: 'QNTGvpnYRVC4HbHibDBUIQ==') }
+
+  it 'should raise for invalid account' do
+    expected_error = [ArgumentError, 'domain required']
+
+    expect { described_class.new(nil, double(:response, code: 401)) }.to raise_error(*expected_error)
+  end
+
+  it 'should raise for invalid response' do
+    expected_error = [ArgumentError, 'response required']
+
+    expect { described_class.new(domain_mock, nil) }.to raise_error(*expected_error)
+  end
+
+  context 'with not success response' do
+    let(:response_not_found) { double(:response_not_found, code: 404) }
+
+    let!(:result) { described_class.new(domain_mock, response_not_found) }
+
+    it 'should have empty content' do
+      expect(result).to be_empty
+    end
+
+    it 'should have last response' do
+      expect(result.last_response).to eq response_not_found
+    end
+  end
+
+  context 'with success response without data' do
+    let(:response_success) do
+      double(code: 200, headers: {}, body: '[]')
+    end
+
+    let!(:result) { described_class.new(domain_mock, response_success) }
+
+    it 'should have empty content' do
+      expect(result).to be_empty
+    end
+
+    it 'should have last response' do
+      expect(result.last_response).to eq response_success
+    end
+  end
+
+  context 'with success response with data' do
+    let(:body) do
+      MultiJson.encode([{
+        account: { digit: "8", number: 1234 },
+        address: "new address",
+        advance_days: 10,
+        agency: { digit: "", number: 354 },
+        agreement_code: "1234",
+        bank: "237",
+        currency: 9,
+        etag: "9c8d4ad41a67770c79ace62b9515adf8b5b0a589",
+        name: "Conta de Cobrança no Bradesco",
+        national_identifier: "03.448.307/9170-25",
+        portfolio_code: "25",
+        sequence_numbers: [ 1, 9999999 ],
+        supplier_name: "Springfield Elemenary School",
+        uri: "http://sandbox.charging.financeconnect.com.br:8080/charge-accounts/29e77bc5-0e70-444c-a922-3149e78d905b/",
+        uuid: "29e77bc5-0e70-444c-a922-3149e78d905b"
+      }])
+    end
+
+    let(:response_success) do
+      double(:response, code: 200, headers: {}, body: body)
+    end
+
+    let(:result) { described_class.new(domain_mock, response_success) }
+
+    it 'should convert into an array of domain' do
+      expect(result.size).to eq 1
+    end
+
+    it 'should have last response' do
+      expect(result.last_response).to eq response_success
+    end
+
+    it 'should contain a domain' do
+      domain = result.first
+
+      expect(domain).to be_an_instance_of(Charging::ChargeAccount)
+    end
+
+    it 'should load current account for domain instance' do
+      expect(result.first.domain).to eq domain_mock
+    end
+  end
+end