bs2_api 0.1.0 → 0.3.2

data/lib/bs2_api/configuration.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Configuration
+  attr_accessor :client_id, :client_secret, :pix_key, :env
+
+  def initialize
+    @env           = ENV.fetch('BS2_ENVIRONMENT', 'sandbox')
+    @client_id     = ENV.fetch('BS2_CLIENT_ID', nil)
+    @client_secret = ENV.fetch('BS2_CLIENT_SECRET', nil)
+  end
+
+  def valid?
+    raise Bs2Api::Errors::MissingConfiguration, 'Missing configuration credentials' if @client_id.blank? || @client_secret.blank?
+  end
+end

data/lib/bs2_api/entities/account.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Entities
+    class Account
+      attr_accessor :bank_code, :bank_name, :agency, :number, :type
+  
+      TYPES = {
+        checking: 'ContaCorrente',
+        salary: 'ContaSalario',
+        saving: 'Poupanca'
+      }
+
+      def initialize(args = {})
+        @bank_code  = args.fetch(:bank_code, nil)
+        @agency     = args.fetch(:agency, nil)
+        @number     = args.fetch(:number, nil)
+        @type       = args.fetch(:type, nil)
+        @bank_name  = get_bank_name
+      end
+
+      def to_hash
+        ActiveSupport::HashWithIndifferentAccess.new(
+          {
+            "banco": @bank_code,
+            "bancoNome": get_bank_name,
+            "agencia": @agency,
+            "numero": @number,
+            "tipo": @type
+          }
+        )
+      end
+
+      def self.from_response(hash_payload)
+        hash = ActiveSupport::HashWithIndifferentAccess.new(hash_payload)
+
+        Bs2Api::Entities::Account.new(
+          bank_code: hash["banco"],
+          bank_name: hash["bancoNome"],
+          agency: hash["agencia"],
+          number: hash["numero"],
+          type: hash["tipo"]
+        )
+      end
+
+      def checking?
+        @type == TYPES[:checking]
+      end
+
+      def salary?
+        @type == TYPES[:salary]
+      end
+
+      def saving?
+        @type == TYPES[:saving]
+      end
+
+      private
+        def get_bank_name
+          Bs2Api::Util::BankService.find_by_code(@bank_code)["name"]
+        end
+    end
+  end
+end

data/lib/bs2_api/entities/bank.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Entities
+    class Bank
+      attr_accessor :ispb, :account, :customer
+
+      def initialize(args = {})
+        @ispb     = args.fetch(:ispb, nil)
+        @account  = args.fetch(:account, nil)
+        @customer = args.fetch(:customer, nil)
+      end
+
+      def to_hash
+        ActiveSupport::HashWithIndifferentAccess.new(
+          {
+            "ispb": get_ispb,
+            "conta": @account.to_hash,
+            "pessoa": @customer.to_hash
+          }
+        )
+      end
+
+      def self.from_response(hash_payload)
+        hash = ActiveSupport::HashWithIndifferentAccess.new(hash_payload)
+
+        Bs2Api::Entities::Bank.new(
+          ispb: hash["ispb"],
+          account: Bs2Api::Entities::Account.from_response(hash["conta"]),
+          customer: Bs2Api::Entities::Customer.from_response(hash["pessoa"])
+        )
+      end
+
+      private
+        def get_ispb
+          Bs2Api::Util::BankService.find_by_code(@account.bank_code)["ispb"]
+        end
+    end
+  end
+end

data/lib/bs2_api/entities/customer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Entities
+    class Customer
+      attr_accessor :document, :type, :name, :business_name
+  
+      TYPES = {
+        personal: 'CPF',
+        business: 'CNPJ'
+      }
+
+      def initialize(args = {})
+        @document      = args.fetch(:document, nil)
+        @type          = args.fetch(:type, 'CPF')
+        @name          = args.fetch(:name, nil)
+        @business_name = args.fetch(:business_name, nil)
+      end
+
+      def to_hash
+        ActiveSupport::HashWithIndifferentAccess.new(
+          {
+            "documento": @document,
+            "tipoDocumento": @type,
+            "nome": @name,
+            "nomeFantasia": @business_name
+          }
+        )
+      end
+
+      def self.from_response(hash_payload)
+        hash = ActiveSupport::HashWithIndifferentAccess.new(hash_payload)
+
+        Bs2Api::Entities::Customer.new(
+          document: hash["documento"],
+          type: hash["tipoDocumento"],
+          name: hash["nome"],
+          business_name: hash["nomeFantasia"]
+        )
+      end
+
+      def personal?
+        @type == TYPES[:personal]
+      end
+      
+      def business?
+        @type == TYPES[:business]
+      end
+    end
+  end
+end

data/lib/bs2_api/entities/payment.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Entities
+    class Payment
+      attr_accessor :id, :merchant_id, :receiver, :payer
+
+      def initialize(args = {})
+        @id          = args.fetch(:id, nil)
+        @merchant_id = args.fetch(:merchant_id, nil)
+        @receiver    = args.fetch(:receiver, nil)
+        @payer       = args.fetch(:payer, nil)
+      end
+
+      def to_hash
+        ActiveSupport::HashWithIndifferentAccess.new(
+          {
+            "pagamentoId": @id,
+            "endToEndId": @merchant_id,
+            "recebedor": @receiver.to_hash,
+            "pagador": @payer.to_hash
+          }
+        )
+      end
+
+      def self.from_response(hash_payload)
+        hash = ActiveSupport::HashWithIndifferentAccess.new(hash_payload)
+
+        Bs2Api::Entities::Payment.new(
+          id: hash["pagamentoId"],
+          merchant_id: hash["endToEndId"],
+          receiver: Bs2Api::Entities::Bank.from_response(hash["recebedor"]),
+          payer: Bs2Api::Entities::Bank.from_response(hash["pagador"])
+        )
+      end
+    end
+  end
+end

data/lib/bs2_api/entities/pix_key.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Entities
+    class PixKey
+      attr_accessor :key, :type
+
+      TYPES = {
+        cpf: 'CPF',
+        cnpj: 'CNPJ',
+        phone: 'PHONE',
+        email: 'EMAIL',
+        random: 'EVP'
+      }
+
+      def initialize(args = {})
+        @key = args.fetch(:key, nil)
+        @type = args.fetch(:type, 'CPF')
+      end
+
+      def to_hash
+        ActiveSupport::HashWithIndifferentAccess.new(
+          {
+            "valor": @key,
+            "tipo": @type
+          }
+        )
+      end
+
+      def self.from_response(hash_payload)
+        hash = ActiveSupport::HashWithIndifferentAccess.new(hash_payload)
+        
+        Bs2Api::Entities::PixKey.new(
+          key: hash["valor"],
+          type: hash["tipo"]
+        )
+      end
+    end
+  end
+end

data/lib/bs2_api/errors/bad_request.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Errors
+    class BadRequest < Base; end
+  end
+end

data/lib/bs2_api/errors/base.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Errors
+    class Base < StandardError; end
+  end
+end

data/lib/bs2_api/errors/confirmation_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Errors
+    class ConfirmationError < Base; end
+  end
+end

data/lib/bs2_api/errors/invalid_bank.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Errors
+    class InvalidBank < Base; end
+  end
+end

data/lib/bs2_api/errors/invalid_customer.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Errors
+    class InvalidCustomer < Base; end
+  end
+end

data/lib/bs2_api/errors/invalid_pix_key.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Errors
+    class InvalidPixKey < Base; end
+  end
+end

data/lib/bs2_api/errors/missing_bank.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Errors
+    class MissingBank < Base; end
+  end
+end

data/lib/bs2_api/errors/missing_configuration.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Errors
+    class MissingConfiguration < Base; end
+  end
+end

data/lib/bs2_api/errors/server_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Errors
+    class ServerError < Base; end
+  end
+end

data/lib/bs2_api/errors/unauthorized.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Errors
+    class Unauthorized < Base; end
+  end
+end

data/lib/bs2_api/initializers/hash.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Hash
+  def queryfy
+    keys.map do |key|
+      "#{key}=#{self[key]}"
+    end.join("&")
+  end
+end

data/lib/bs2_api/initializers/object.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Object
+  def blank?
+    respond_to?(:empty?) ? !!empty? : !self
+  end
+
+  def present?
+    !blank?
+  end
+end

data/lib/bs2_api/payment/base.rb

@@ -0,0 +1,59 @@
+module Bs2Api
+  module Payment
+    class Base
+      attr_reader :payment
+
+      def initialize
+        raise NoMethodError, "Missing #{__method__} to #{self.class}"
+      end
+
+      def call
+        response = post_request
+        raise Bs2Api::Errors::BadRequest, parse_error(response) unless response.created?
+        
+        @payment = Bs2Api::Entities::Payment.from_response(response)
+        self
+      end
+
+      private
+        def post_request
+          HTTParty.post(url, headers: headers, body: payload.to_json)
+        end
+
+        def headers
+          {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Authorization": "Bearer #{bearer_token}"
+          }
+        end
+
+        def bearer_token
+          Bs2Api::Request::Auth.token
+        end
+
+        def parse_error(response)
+          hash    = JSON.parse(response.body)
+          message = "#{response.code}: "
+
+          if hash.is_a?(Array)
+            message << hash[0]["descricao"]
+          elsif hash.key?("error_description")
+            message << hash["error_description"]
+          else 
+            message << hash.to_s
+          end
+
+          message
+        end
+
+        def payload
+          raise NoMethodError, "Missing #{__method__} to #{self.class}"
+        end
+        
+        def url
+          raise NoMethodError, "Missing #{__method__} to #{self.class}"
+        end
+    end
+  end
+end

data/lib/bs2_api/payment/confirmation.rb

@@ -0,0 +1,38 @@
+module Bs2Api
+  module Payment
+    class Confirmation < Base
+      attr_reader :success
+
+      def initialize payment, value: nil
+        raise Bs2Api::Errors::ConfirmationError, 'invalid payment' unless payment.present? && payment.is_a?(Bs2Api::Entities::Payment)
+        raise Bs2Api::Errors::ConfirmationError, 'invalid value' unless value.to_f.positive?
+        @payment = payment
+
+        @value = value.to_f
+      end
+
+      def call
+        response = post_request
+        raise Bs2Api::Errors::ConfirmationError, parse_error(response) unless response.accepted?
+
+        @success = true
+        self
+      end
+
+      private
+        def payload
+          @payment.to_hash
+                  .except!("pagamentoId", "endToEndId")
+                  .merge("valor": @value)
+        end
+        
+        def url
+          "#{Bs2Api.endpoint}/pix/direto/forintegration/v1/pagamentos/#{@payment.id}/confirmacao"
+        end
+
+        def success?
+          !!@success
+        end
+    end
+  end
+end