bs2_api 1.2.2 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 175c6176282d4442f464f85434429c42278b5fd0553cd2a4ac03fc65fe813096
-  data.tar.gz: 6a5edaca9bc8aefcebd1a00699faaf0615c44816290cf0c87e4d14a4a4d74bc9
+  metadata.gz: 7ba55ce23aae59313a798b0b5d983e29b7a5ef279810d795b513b99888196811
+  data.tar.gz: c61832cf0382e1d9b1be22615963303d6f3c4e8bfdf2fe217cd2292e4082a5a3
 SHA512:
-  metadata.gz: 11ed0de57717ada3d4cc18e9859c8d323eca009fea97086bbee877e1052ced9bc8c2e014cb9cd1c7478a0a61852653e1c7c563a8cbfd518a8a81e6e45dfed6db
-  data.tar.gz: e95bc5444784271372d3d2be1e3246ac47cf81a9667cbe7c3fe668490fa5171234dbbf69ab02c95fe54b5cf5a3113d7561684dc64977779408cbc24b3c19326b
+  metadata.gz: 9b5a00b54f7c859977f81041da155713e625988f5432c76e6f3d8d6c5f1448594685e6c7933690cabae03c5cec08a35c4f22a07fec4e7908ab5d0226fca9e746
+  data.tar.gz: 9c74747a9be8e1f0b064e46de4a8a8345c1f162417e7c155fabeab98f3c00999f0e712bb942c2f4599d0e584c33c3d92e675df0beb71a015d37f6a71b270681e

data/.gitignore

@@ -6,6 +6,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+/vendor/
 
 # rspec failure tracking
 .rspec_status
@@ -13,5 +14,9 @@
 *.gem
 
 .env.test
+.env.*.local
 
-/.idea/
+/.idea/
+*.swp
+*.swo
+.byebug_history

data/Gemfile

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
-gemspec
+group :development, :test do
+  gem 'factory_bot', '~> 6.1'
+  gem 'pry-byebug', '~> 3.7'
+end
+
+gemspec

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    bs2_api (1.2.1)
+    bs2_api (1.3.2)
       activesupport
       builder
       bundler
@@ -26,6 +26,8 @@ GEM
       rexml
     diff-lcs (1.4.4)
     dotenv (2.7.6)
+    factory_bot (6.2.1)
+      activesupport (>= 5.0.0)
     hashdiff (1.0.1)
     httparty (0.18.1)
       mime-types (~> 3.0)
@@ -80,7 +82,8 @@ PLATFORMS
 DEPENDENCIES
   bs2_api!
   dotenv (~> 2.7, >= 2.7.6)
-  pry-byebug (~> 3.9)
+  factory_bot (~> 6.1)
+  pry-byebug (~> 3.7)
   rspec (~> 3.10)
   uuid (~> 2.3, >= 2.3.9)
   vcr (~> 6.0)

data/README.md

@@ -147,6 +147,46 @@ payment.class
 => Bs2Api::Entities::Payment
 ```
 
+
+### Async API
+Add initial asyc BS2 API implementation.
+    
+The API allows to pass multiple request all at once. In order to do so you must:
+1. Create `Bs2Api::Payment::Async`
+2. Create one or more PIX keys
+3. For each PIX key create `Bs2Api::Entities::AsyncRequest` passing in the PIX key, internal identifier and the value of the transaction
+4. Add each async request to the async payment via `Bs2Api::Payment::Async#add_request`
+5. When all requests are added call `Bs2Api::Payment::Async#call`
+6. In the response you will get list of payments of type `Bs2Api::Entities::AsyncResponse` whose confirmation will be sent via webhook
+6.1 If even one of the requests has invalid data, the response will be 400 and we won't get anything via webhook
+7. If the response from 6 was 202 but we don't get a webhook notification we should start polling the response manually. This is done by calling `Bs2Api::Payment::Async::check_payment_status`. It has one parameter the `Bs2Api::Entities::AsyncResponse#request_id`.The result from this will be `Bs2Api::Entities::AsyncStatus`, using it you can check if the payment was rejected or confirmed.
+
+```ruby
+ pix_key = Bs2Api::Entities::PixKey.new(
+  key: 'joao@gmail.com',
+  type: 'EMAIL'
+)
+
+async_request = Bs2Api::Entities::AsyncRequest.new(
+  pix_key: pix_key,
+  value: 10.0,
+  identificator: 'payment1'
+)
+
+async_payment = Bs2Api::Payment::Async.new
+async_payment.add_request(async_request)
+
+response_list = async_payment.call
+
+# Wait for webhook if notification does not arrive (for example for the first item)
+response_status = Bs2Api::Payment::Async.check_payment_status(response_list[0].request_id)
+
+# Check the status
+if response_status.rejected?
+  puts response_status.rejection_description
+end
+```
+
 ### Classes de erros:
 ```ruby
 # Todos erros herdam de:
@@ -166,4 +206,4 @@ Bs2Api::Errors::Unauthorized
 
 ### Observações
 - Método `call` retorna o próprio objeto
-- Em caso de retorno diferente de sucesso na comunicação com a API do Bs2, um erro sempre será lançado.
+- Em caso de retorno diferente de sucesso na comunicação com a API do Bs2, um erro sempre será lançado.

data/lib/bs2_api/entities/async_request.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Entities
+    # Used by Bs2Api::Payment::Async. This class stores
+    # PIX key, user defined identificador for the key and
+    # the value to be transfered. Bs2Api::Payment::Async
+    # sends a bucket of AsyncRequest and in the response
+    # we get a list of passed payments. The identificador
+    # can be used to keep track of the transactino in the
+    # response.
+    class AsyncRequest
+      attr_accessor :identificator, :pix_key, :value
+
+      ALLOWED_PIX_KEY_TYPES = %w[
+        CPF
+        CNPJ
+        EMAIL
+        EVP
+      ].freeze
+
+      def initialize(args = {})
+        @pix_key = args[:pix_key]
+        raise Errors::InvalidPixKey unless ALLOWED_PIX_KEY_TYPES.include? @pix_key.type
+
+        @identificator = args.fetch(:identificator)
+        @value = args[:value]
+      end
+
+      def to_hash
+        ActiveSupport::HashWithIndifferentAccess.new(
+          {
+            identificador: @identificator,
+            chave: @pix_key.to_hash,
+            valor: @value
+          }
+        )
+      end
+
+      def to_json(*)
+        to_hash.to_json
+      end
+    end
+  end
+end

data/lib/bs2_api/entities/async_response.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Entities
+    # After we send async payment request via calling Bs2Api::Payment::Async#call
+    # the API is expected to return array of JSON objects describing each payment
+    # this class is used to wrap those JSON objects
+    # identificator is optional and is for internal purposes it won't be sent via
+    # the webhook when the payment confirmation is done.
+    # request_id is the id of the payment which the bank will send via webhook
+    class AsyncResponse
+      attr_accessor :identificator, :pix_key, :value, :error, :request_id
+
+      class << self
+        def from_response(input_hash)
+          pix_key = PixKey.new(
+            key: input_hash['chave']['valor'],
+            type: input_hash['chave']['tipo']
+          )
+          AsyncResponse.new(
+            identificator: input_hash['identificador'],
+            pix_key: pix_key,
+            value: input_hash['valor'],
+            error: input_hash['erros'],
+            request_id: input_hash['solicitacaoId']
+          )
+        end
+      end
+
+      def initialize(args = {})
+        @identificator = args.fetch(:identificator, '')
+        @pix_key = args[:pix_key]
+        @value = args[:value]
+        @error = args[:error]
+        @request_id = args[:request_id]
+      end
+    end
+  end
+end

data/lib/bs2_api/entities/async_status.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Entities
+    # Used with Bs2Api::Payment::Async. When we call
+    # Bs2Api::Payment::Async#call we expect to get data for each
+    # item in the bucket via webhook. If we don't get webhooks in
+    # a few seconds (roughly about 10s) we should start polling the
+    # status of the payment by calling # Bs2Api::Payment::Async::check_payment_status.
+    # The following # class is used to wrap the result of
+    # Bs2Api::Payment::Async::check_payment_status
+    class AsyncStatus
+      attr_accessor :request_id, :payment_id, :end_to_end_id, :status,
+                    :agency, :number, :pix_key, :value, :free_field,
+                    :rejection_description, :error_description
+
+      class << self
+        # Parses the has from the response body of
+        # Bs2Api::Payment::Async::check_payment_status
+        # @param[Hash] The response body as a hash with string keys
+        def from_response(hash)
+          new(
+            request_id: hash['solicitacaoId'],
+            payment_id: hash['pagamentoId'],
+            end_to_end_id: hash['endToEndId'],
+            status: STATUS[hash['status']],
+            agency: hash['agencia'],
+            number: hash['numero'],
+            pix_key: Bs2Api::Entities::PixKey.from_response(hash['chave']),
+            value: hash['valor'],
+            free_field: hash['campoLivre'],
+            rejection_description: hash['rejeitadoDescricao'],
+            error_description: hash['erroDescricao']
+          )
+        end
+      end
+
+      STATUS = {
+        'Realizado' => :awaiting_validation,
+        'Iniciado' => :in_process,
+        'Confirmado' => :confirmed,
+        'Rejeitado' => :rejected,
+        'Erro' => :error
+      }.freeze
+
+      def initialize(args = {})
+        @request_id = args[:request_id]
+        @payment_id = args[:payment_id]
+        @end_to_end_id = args[:end_to_end_id]
+        @status = args[:status]
+        @agency = args[:agency]
+        @number = args[:number]
+        @pix_key = args[:pix_key]
+        @value = args[:value]
+        @free_field = args[:free_field]
+        @rejection_description = args[:rejection_description]
+        @error_description = args[:error_description]
+      end
+
+      def rejected?
+        @status == :rejected
+      end
+
+      def confirmed?
+        @status == :confirmed
+      end
+
+      def error?
+        @status == :error
+      end
+    end
+  end
+end

data/lib/bs2_api/entities/pix_key.rb

@@ -11,7 +11,7 @@ module Bs2Api
         phone: 'PHONE',
         email: 'EMAIL',
         random: 'EVP'
-      }
+      }.freeze
 
       def initialize(args = {})
         @key = args.fetch(:key, nil)

data/lib/bs2_api/payment/async.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Payment
+    # Class used to store a bucket of requests which will be sent
+    # altogether.
+    class Async < Base
+      attr_reader :requests
+
+      class << self
+        # Check the status of a request manually. Usually we will be notified
+        # via webhook, but in case we do not get notification for a specific
+        # payment we need to start to poll the BS2 API manually.
+        #
+        # @param[String] request_id The id (SolicitacaoId) for the payment
+        # returned by Bs2Api::Payment::Async#call
+        # @param[String] client_id ID of the client issued by BS2 used for
+        # authorizatino. Optional, if not passed the default will be used
+        # @param[String] client_secret The password for the account with
+        # id client_id. Optional, if not passed the default will be used.
+        def check_payment_status(
+          request_id,
+          client_id: Bs2Api.configuration.client_id,
+          client_secret: Bs2Api.configuration.client_secret
+        )
+          url = request_status_url(request_id)
+          bearer_token = Bs2Api::Request::Auth.token(
+            client_id: client_id,
+            client_secret: client_secret
+          )
+          headers = { 'Authorization': "Bearer #{bearer_token}" }
+          response = HTTParty.get(url, headers: headers)
+          Bs2Api::Entities::AsyncStatus.from_response response.parsed_response
+        end
+
+        private
+
+        # The url where one can manually check the status of an async request
+        #
+        # @param[String] request_id The id (SolicitacaoId) for the payment
+        # returned by Bs2Api::Payment::Async#call
+        def request_status_url(request_id)
+          "#{Bs2Api.endpoint}/pix/direto/forintegration/v1/pagamentos/chave/solicitacoes/#{request_id}"
+        end
+      end
+
+      def initialize(
+        client_id: Bs2Api.configuration.client_id,
+        client_secret: Bs2Api.configuration.client_secret
+      )
+        @client_id = client_id
+        @client_secret = client_secret
+        @requests = []
+      end
+
+      # Push request into the request bucker. This will not send the request.
+      # When Bs2Api::Payment::Async#call is called all requeststs from the bucket
+      # will be sent simultaneously
+      #
+      # @param[Bs2Api::Entities::AsyncRequest] The async request which is going
+      # to be placed in the bucket
+      def add_request(request)
+        @requests << request
+      end
+
+      # Get the size of the bucket list
+      def requests_count
+        @requests.length
+      end
+
+      # The response from call differs from Payment::Base#call because
+      # for the async method we get 202 and a list of payment transactions IDs
+      # Later on we will notified via webhook for all payments transactions
+      # which were successful.
+      #
+      # @important The API call will fail if even one of the bucket items has
+      # data (PIX key, value, etc).
+      #
+      # @return[Hash] List of payments which we should expect to be confirmed via
+      # webhook. The response will contain field "SolicitacaoId" genreated by BS2
+      # this ID is used to match the payment in the webhook
+      def call
+        response = post_request
+        raise Bs2Api::Errors::BadRequest, ::Util::Response.parse_error(response) unless response.code == 202
+
+        response.parsed_response.map do |async_response|
+          Bs2Api::Entities::AsyncResponse.from_response(async_response)
+        end
+      end
+
+      private
+
+      # The url which will be called in order to send the bucket request for processing
+      def url
+        "#{Bs2Api.endpoint}/pix/direto/forintegration/v1/pagamentos/chave/solicitacoes"
+      end
+
+      def payload
+        {
+          "solicitacoes": @requests
+        }
+      end
+    end
+  end
+end

data/lib/bs2_api/payment/base.rb

@@ -16,29 +16,33 @@ module Bs2Api
       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 payload
-          raise NoMethodError, "Missing #{__method__} to #{self.class}"
-        end
-
-        def url
-          raise NoMethodError, "Missing #{__method__} to #{self.class}"
-        end
+
+      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(
+          client_id: @client_id || Bs2Api.configuration.client_id,
+          client_secret: @client_secret || Bs2Api.configuration.client_secret
+        )
+      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/detail.rb

@@ -3,7 +3,13 @@ module Bs2Api
     class Detail < Base
       attr_reader :success
 
-      def initialize payment_id
+      def initialize(
+        payment_id,
+        client_id: Bs2Api.configuration.client_id,
+        client_secret: Bs2Api.configuration.client_secret
+      )
+        @client_id = client_id
+        @client_secret = client_secret
         @payment_id = payment_id
       end
 
@@ -15,13 +21,21 @@ module Bs2Api
       end
 
       private
-        def url
-          "#{Bs2Api.endpoint}/pix/direto/forintegration/v1/pagamentos/#{@payment_id}"
-        end
 
-        def detail_request
-          HTTParty.get(url, headers: headers)
-        end
+      def url
+        "#{Bs2Api.endpoint}/pix/direto/forintegration/v1/pagamentos/#{@payment_id}"
+      end
+
+      def detail_request
+        HTTParty.get(url, headers: headers)
+      end
+
+      def bearer_token
+        Bs2Api::Request::Auth.token(
+          client_id: @client_id,
+          client_secret: @client_secret
+        )
+      end
     end
   end
 end

data/lib/bs2_api/pix/detail.rb

@@ -0,0 +1,52 @@
+module Bs2Api
+  module Pix
+    class Detail
+      def initialize(
+        client_id:,
+        client_secret:,
+        end_to_end_id:,
+        time_range:,
+        transaction_id: nil,
+        proxy: nil
+      )
+        @client_id = client_id
+        @client_secret = client_secret
+        @end_to_end_id = end_to_end_id
+        @time_range = time_range
+        @transaction_id = transaction_id
+        @proxy = proxy
+      end
+
+      def call
+        url = "#{Bs2Api.endpoint}/pix/direto/forintegration/v1/recebimentos/#{@end_to_end_id}/recebimento"
+
+        access_token = Bs2Api::Request::Auth.token(
+          client_id: @client_id,
+          client_secret: @client_secret
+        )
+
+        response = HTTParty.get(
+          url,
+          http_proxyaddr: @proxy&.host,
+          http_proxyport: @proxy&.port,
+          http_proxyuser: @proxy&.user,
+          http_proxypass: @proxy&.password,
+          headers: {
+            'Content-Type' => 'application/json',
+            'Accept' => 'application/json',
+            'Authorization' => "Bearer #{access_token}",
+          },
+          query: {
+            Inicio: @time_range.begin.iso8601,
+            Fim: @time_range.end.iso8601,
+            TxId: @transaction_id,
+          }
+        )
+
+        raise response.body unless response.success?
+
+        response.body
+      end
+    end
+  end
+end

data/lib/bs2_api/refund/pix/create.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Bs2Api
+  module Refund
+    module Pix
+      class Create
+        def initialize(
+         client_id:,
+          client_secret:,
+          end_to_end_id:,
+          transaction_id:,
+          value:,
+          proxy: nil
+        )
+          @client_id = client_id
+          @client_secret = client_secret
+          @end_to_end_id = end_to_end_id
+          @transaction_id = transaction_id
+          @value = value
+          @proxy = proxy
+        end
+
+        # https://devs.bs2.com/manual/pix-clientes/#tag/Devolucoes-Cliente/paths/~1pix~1direto~1forintegration~1v1~1pix~1{e2eid}~1devolucao~1{idExterno}/put
+        def call
+          url = "#{Bs2Api.endpoint}/pix/direto/forintegration/v1/pix/#{@end_to_end_id}/devolucao/#{@transaction_id}"
+
+          access_token = Bs2Api::Request::Auth.token(
+            client_id: @client_id,
+            client_secret: @client_secret
+          )
+
+          # TODO: is PUT the right method?
+          response = HTTParty.put(
+            url,
+            http_proxyaddr: @proxy&.host,
+            http_proxyport: @proxy&.port,
+            http_proxyuser: @proxy&.user,
+            http_proxypass: @proxy&.password,
+            headers: {
+              'Content-Type' => 'application/json',
+              'Accept' => 'application/json',
+              'Authorization' => "Bearer #{access_token}",
+            },
+            body: {
+              valor: value
+            }.to_json
+          )
+
+          raise response.body unless response.success?
+
+          response.body
+        end
+      end
+    end
+  end
+end

data/lib/bs2_api/refund/pix/detail.rb

@@ -0,0 +1,58 @@
+module Bs2Api
+  module Refund
+    module Pix
+      class Detail
+        STATUSES = {
+          'EM_PROCESSAMENTO' => :processing,
+          'DEVOLVIDO' => :refunded,
+          'NAO_REALIZADO' => :not_achieved,
+        }.transform_keys(&:downcase).freeze
+
+        def initialize(
+          client_id:,
+          client_secret:,
+          end_to_end_id:,
+          transaction_id:,
+          proxy: nil
+        )
+          @client_id = client_id
+          @client_secret = client_secret
+          @end_to_end_id = end_to_end_id
+          @transaction_id = transaction_id
+          @proxy = proxy
+        end
+
+        # https://devs.bs2.com/manual/pix-clientes/#tag/Devolucoes-Cliente/paths/~1pix~1direto~1forintegration~1v1~1pix~1{e2eid}~1devolucao~1{idExterno}/get
+        def call
+          url = "#{Bs2Api.endpoint}/pix/direto/forintegration/v1/pix/#{@end_to_end_id}/devolucao/#{@transaction_id}"
+
+          access_token = Bs2Api::Request::Auth.token(
+            client_id: @client_id,
+            client_secret: @client_secret
+          )
+
+          response = HTTParty.get(
+            url,
+            http_proxyaddr: @proxy&.host,
+            http_proxyport: @proxy&.port,
+            http_proxyuser: @proxy&.user,
+            http_proxypass: @proxy&.password,
+            headers: {
+              'Content-Type' => 'application/json',
+              'Accept' => 'application/json',
+              'Authorization' => "Bearer #{access_token}",
+            }
+          )
+
+          raise response.body unless response.success?
+
+          response.body
+        end
+
+        def status
+          @status ||= STATUSES.fetch(call.fetch('status'))
+        end
+      end
+    end
+  end
+end

data/lib/bs2_api/request/auth.rb

@@ -3,28 +3,55 @@
 module Bs2Api
   module Request
     class Auth
+      # TODO: See which scopes are required.
+      SCOPES = [
+        'saldo',
+        'extrato',
+        'pagamento',
+        'transferencia',
+        'cobv.write',
+        'cobv.read',
+        'comprovante',
+        'webhook-mov-conta',
+        'aprovacoes',
+        'pagamento-tributo',
+        'webhook-conclusao-transf',
+        'webhook-conclusao-pag',
+        'cob.write',
+        'cob.read',
+        'pix.write',
+        'pix.read',
+        'dict.write',
+        'dict.read',
+        'webhook.read',
+        'webhook.write',
+      ].freeze
+
       class << self
-        def token
+        def token(
+          client_id: Bs2Api.configuration.client_id,
+          client_secret: Bs2Api.configuration.client_secret
+        )
           Bs2Api.configuration.valid?
 
-          response = create_session
+          response = create_session(client_id, client_secret)
 
-          raise Bs2Api::Errors::Unauthorized, response["error_description"] if response.unauthorized?
-          raise Bs2Api::Errors::BadRequest, response["error_description"] if response.bad_request?
-          raise Bs2Api::Errors::ServerError, response.body if !response.success?
+          raise Bs2Api::Errors::Unauthorized, response['error_description'] if response.unauthorized?
+          raise Bs2Api::Errors::BadRequest, response['error_description'] if response.bad_request?
+          raise Bs2Api::Errors::ServerError, response.body unless response.success?
 
-          response["access_token"]
+          response['access_token']
         end
 
         private
-          def create_session
+          def create_session(client_id, client_secret)
             HTTParty.post(
               auth_url,
               headers: headers,
               body: body,
               basic_auth: {
-                username: Bs2Api.configuration.client_id,
-                password: Bs2Api.configuration.client_secret
+                username: client_id,
+                password: client_secret
               }
             )
           end
@@ -39,14 +66,14 @@ module Bs2Api
           def body
             {
               grant_type: "client_credentials",
-              scope: "pix.write pix.read"
+              scope: SCOPES.join("\s")
             }.to_query
           end
 
           def auth_url
             "#{Bs2Api.endpoint}/auth/oauth/v2/token"
           end
-     end
+      end
     end
   end
 end

data/lib/bs2_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bs2Api
-  VERSION = "1.2.2"
+  VERSION = '1.4.0'
 end

data/lib/bs2_api.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
-require "httparty"
-require "active_support/core_ext/hash/indifferent_access"
-require "active_support/core_ext/hash/except"
-require "active_support/core_ext/object/to_query"
-require "active_support/core_ext/object/blank"
+
+require 'httparty'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/object/to_query'
+require 'active_support/core_ext/object/blank'
 
 require 'bs2_api/version'
 require 'bs2_api/configuration'
@@ -26,20 +27,28 @@ require 'bs2_api/entities/bank'
 require 'bs2_api/entities/customer'
 require 'bs2_api/entities/payment'
 require 'bs2_api/entities/pix_key'
+require 'bs2_api/entities/async_request'
+require 'bs2_api/entities/async_response'
+require 'bs2_api/entities/async_status'
 
 require 'bs2_api/payment/base'
 require 'bs2_api/payment/key'
 require 'bs2_api/payment/manual'
 require 'bs2_api/payment/confirmation'
 require 'bs2_api/payment/detail'
+require 'bs2_api/payment/async'
 
 require 'bs2_api/request/auth'
 
+
+require 'bs2_api/refund/pix/create'
+require 'bs2_api/refund/pix/detail'
+
 module Bs2Api
   ENDPOINT = {
     production: 'https://api.bs2.com',
     sandbox: 'https://apihmz.bancobonsucesso.com.br'
-  }
+  }.freeze
 
   class << self
     attr_writer :configuration

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bs2_api
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.4.0
 platform: ruby
 authors:
 - Kim Pastro
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-05-27 00:00:00.000000000 Z
+date: 2022-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -201,6 +201,9 @@ files:
 - lib/bs2_api.rb
 - lib/bs2_api/configuration.rb
 - lib/bs2_api/entities/account.rb
+- lib/bs2_api/entities/async_request.rb
+- lib/bs2_api/entities/async_response.rb
+- lib/bs2_api/entities/async_status.rb
 - lib/bs2_api/entities/bank.rb
 - lib/bs2_api/entities/customer.rb
 - lib/bs2_api/entities/payment.rb
@@ -215,11 +218,15 @@ files:
 - lib/bs2_api/errors/missing_configuration.rb
 - lib/bs2_api/errors/server_error.rb
 - lib/bs2_api/errors/unauthorized.rb
+- lib/bs2_api/payment/async.rb
 - lib/bs2_api/payment/base.rb
 - lib/bs2_api/payment/confirmation.rb
 - lib/bs2_api/payment/detail.rb
 - lib/bs2_api/payment/key.rb
 - lib/bs2_api/payment/manual.rb
+- lib/bs2_api/pix/detail.rb
+- lib/bs2_api/refund/pix/create.rb
+- lib/bs2_api/refund/pix/detail.rb
 - lib/bs2_api/request/auth.rb
 - lib/bs2_api/util/response.rb
 - lib/bs2_api/version.rb